【LeetCode】Valid Parentheses && Generate Parentheses && Longest Valid Parentheses

这三道题都是括号匹配问题。
1、Valid Parentheses 
      Total Accepted: 5225 Total Submissions: 18918 My Submissions
      Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.
      The brackets must close in the correct order, "()" and "()[]{}" are all valid but "(]" and "([)]" are not.
      这个是校验括号是否匹配，这个很简单，用栈去模拟。发现是左括号就入栈，发现是右括号，而且和左括号匹配就出栈。
      最后判断栈是否为空，如果是空的，说明所给的括号序列是匹配的，return true，否则的话，就是有不匹配的出现，直接return false。
      这个题和九度题目1342：寻找最长合法括号序列II（25分）一样(解题思路见Jobdu 题目1342：寻找最长合法括号序列II(25分))
Java AC

public class Solution {
    public boolean isValid(String s) {
        if(s == null || "".equals(s.trim())){
            return false; 
        }
        char array[] = s.toCharArray();
        int len = s.length();
        Stack<Character> stack = new Stack<Character>();
        for(int i = 0; i < len; i++){
            if(array[i] == '(' || array[i] == '{' || array[i] == '['){
                stack.push(array[i]);
            }else if(array[i] == ')' || array[i] == '}' || array[i] == ']'){
                if(stack.isEmpty()){
                    return false;
                }
                char c = stack.peek();
                stack.pop();
                if(array[i] == ')'){
                    if(c != '('){
                        return false;
                    }
                }
                if(array[i] == '}'){
                    if(c != '{'){
                        return false;
                    }
                }
                if(array[i] == ']'){
                    if(c != '['){
                        return false;
                    }
                }
            }
        }
        if(!stack.isEmpty()){
            return false;
        }
        return true;
    }
}

2、Generate Parentheses
      Total Accepted: 5509 Total Submissions: 18045 My Submissions
      Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
      For example, given n = 3, a solution set is:
      "((()))", "(()())", "(())()", "()(())", "()()()"
      这个是需要产生合法的括号匹配。
      这个就不能用栈去模拟了，需要dfs来产生。
      分别累加左右括号，如果左括号的个数为n了，那么剩下的就只能添加右括号了，这样就产生一个合法的括号序列了。
      如果左括号个数小于n的话，就可以添加左括号。添加右括号的时候判断一下，如果左括号比右括号多，就累加产生右括号。
      否则的话，就只能添加左括号，这样做的原因是，如果右括号多，还一直添加必然会产生不合法的括号序列。
Java AC

public class Solution {
    public ArrayList<String> generateParenthesis(int n) {
		ArrayList<String> list = new ArrayList<String>();
		if (n <= 0) {
			return list;
		}	
		dfs(list, "", n, 0, 0);
		return list;
	}
	public void dfs(ArrayList<String> list, String sb, int n,int leftNum, int rightNum) {
		if (leftNum == n) {
			for(int i = 0; i < n - rightNum; i++) {  
                sb += ")";  
            }  
			list.add(sb);
			return;
		}
		dfs(list, sb+"(", n, leftNum+1, rightNum);
		if (leftNum > rightNum) {
			dfs(list, sb+")", n, leftNum, rightNum+1);
		}
	}
}

3、Longest Valid Parentheses 
      Total Accepted: 4080 Total Submissions: 22189 My Submissions
      Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring.
      For "(()", the longest valid parentheses substring is "()", which has length = 2.
      Another example is ")()())", where the longest valid parentheses substring is "()()", which has length = 4.
      这个是判断最长的连续的合法括号序列，这个题比九度题目1337：寻找最长合法括号序列(解题思路见Jobdu 题目1337：寻找最长合法括号序列)，同时可以参考一下题目1153：括号匹配问题(解题思路Jobdu 题目1153：括号匹配问题)要容易一些，其实也差不多，但是九度需要统计最长的连续的合法括号序列有几个，每个有多长。
       同样，和第一题一样，我们可以使用栈，同时声明数组flag来标记当前位置的括号是否可以匹配成功。
入栈的是括号在原字符串中的序号，是发现是左括号就将当前序号入栈，发现是右括号就将栈顶元素弹出，同时设定当时的标记位为1，也就是找到一个合法的括号匹配序列了。扫描一遍之后，就将所有可以匹配的括号标记为1了。那么我们扫描标记数组flag，发现是连续的1，长度就可以累加，这样就能统计出结果了。

Java AC

public class Solution {
    public int longestValidParentheses(String s) {
        if(s == null || "".equals(s.trim())){
            return 0;
        }
        char array[] = s.toCharArray();
        int len = s.length();
        Stack<Integer> stack = new Stack<Integer>();
        int flag[] = new int[len];
        for(int i = 0; i < len; i++){
            if(array[i] == '(') {
                stack.push(i);
            }else{
                if(!stack.isEmpty()){
                    int j = stack.pop();
                    flag[i] = 1;
                    flag[j] = 1;
                }
            }
        }
        int maxLen = 0;
        int tempLen = 0;
        for(int i = 0; i < len; i++){
            if(flag[i] == 1) {
                tempLen++;
            }else{
                tempLen = 0;
            }
            if(tempLen > maxLen){
                maxLen = tempLen;
            }
        }
        return maxLen;
    }
}