Longest Valid Parentheses

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.

这个题很典型的使用stack来解即可。

想法是存上每个‘（’之前已经匹配的括号数量。
比如
（）（（）（）（（）
第1次遇到前括号，入栈数字是0，然后遇到后括号，现在的长度是2+0
第2次遇到前括号，入栈数字是2，当前长度重设为0
第3次遇到前括号，入栈数字是当前长度0.然后后括号，出栈，长度是2+0，
第4次遇到前括号，入栈数字是当前长度2.然后后括号，出栈，长度是2+2，
第5次遇到前括号，入栈数字是当前长度4，当前长度重设为0
第6次遇到前括号，入栈数字是当前长度0，遇到后括号，出栈，长度是2.
如果栈内仍有数字，目前是2，4，则全部出栈，和当前长度2比。取最长为4.

public class Solution {
    public int longestValidParentheses(String s) {
        // Start typing your Java solution below
        // DO NOT write main() function
      Stack<Integer> stack = new Stack<Integer>();
      int len = 0;
      int maxLen = 0;
      for(int i = 0; i < s.length(); ++i) {
          if(s.charAt(i) == '(') {
              stack.push(len);
              len = 0;
          } else {
              if (stack.empty()) {
                  maxLen = Math.max(maxLen, len);
                  len = 0;
              } else {
                  len = len + 2 + stack.pop();
              }
          }
      }
      while(!stack.empty()) {
          maxLen = Math.max(maxLen, stack.pop());
      }
      return Math.max(maxLen, len);
    }
}

 DP 解法：

这道题可以用一维动态规划逆向求解。假设输入括号表达式为String s，维护一个长度为s.length的一维数组dp[]，数组元素初始化为0。 dp[i]表示从s[i]到s[s.length - 1]最长的有效匹配括号子串长度， 且这个有效匹配括号一定是从i开始的。则存在如下关系：

• dp[s.length - 1] = 0;
• 从i - 2 -> 0逆向求dp[]，并记录其最大值。若s[i] == '('，则在s中从i开始到s.length - 1计算s[i]的值。这个计算分为两步，通过dp[i + 1]进行的（注意dp[i + 1]已经在上一步求解）：
  • 在s中寻找从i + 1开始的有效括号匹配子串长度，即dp[i + 1]，跳过这段有效的括号子串，查看下一个字符，其下标为j = i + 1 + dp[i + 1]。若j没有越界，并且s[j] == ‘)’，则s[i ... j]为有效括号匹配，dp[i] =dp[i + 1] + 2。
  • 在求得了s[i ... j]的有效匹配长度之后，若j + 1没有越界，则dp[i]的值还要加上从j + 1开始的最长有效匹配，即dp[j + 1]。

public int longestValidParentheses(String s) {
        int n = s.length();
        int[] dp = new int[n+1];
        int max = 0;
        for(int i = n-2; i >= 0; i--) {
            if(s.charAt(i) == '(') {
                int j = i+1+dp[i+1];
                if(j < n && s.charAt(j) == ')') {
                    dp[i] = 2+dp[i+1]+dp[j+1];
                    max = Math.max(max, dp[i]);
                }
            }
        }
        
        return max;
    }

第二遍：使用和 Largest Rectangle in Histogram 类似的思想做。 这里有一个问题 就是如果都规约到了栈空的时候该如何存， 即 () () 这种情况， 所以这时候使用一个变量base。 再就是如果出现了)  而栈里已经没有( 该怎么办。 这时其实出来base 没有和max比较 其他都已经比较了， 所以将base 和 max 比较，然后清空全部东西。

public class Solution {
    public int longestValidParentheses(String s) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if(s == null || s.length() == 0) return 0;
        Stack<Integer> st = new Stack<Integer>();// 栈里存的是已匹配的最长长度
        int max = 0;
        int base = 0;
        for(int i = 0; i < s.length(); i ++){
            if(s.charAt(i) == '('){
                st.push(0);
            }else if(s.charAt(i) == ')' && !st.isEmpty()){//当是）时 进行匹配，消去当前的这一对。并更新最长长度。
                int tmp = st.pop() + 2;
                max = tmp > max ? tmp : max;
                if(!st.isEmpty()){//栈里还有未配对的（
                st.push(tmp + st.pop());
                }else{//栈已经空了，更新base
                    base += tmp;
                }
            }else{// ）多了
                max = base > max ? base : max;
                base = 0;
                st = new Stack<Integer>();
            }
        }
        while(!st.isEmpty()){// 查看栈里剩余的那些最长长度， 这些都是没有配对完的。
            int tmp = st.pop();
            max = tmp > max ? tmp : max;
        }
        max = base > max ? base : max;
        return max;
    }
}

 第三遍：

先向stack里面放个0 用于都匹配成功的时候存放匹配的个数。

每当遇到（ 时， 放一个0， 说明从这个（开始没有匹配成功一对。

每当遇到）时， 如果stack 的 size > 0， 说明还有（没用完，那么进行一次匹配 ==> 将其从stack中取出， 并且将结果加到下一层的（中。

                      如果 size ==1 ，说明之前所有的（都用完了， 所以重置stack。

public class Solution {
    public int longestValidParentheses(String s) {
        if(s == null || s.length() == 0) return 0;
        LinkedList<Integer> ll = new LinkedList<Integer>();
        ll.push(0); // this is the bot of the stack(nothing in the stack yet)
        int max = 0;
        for(int i = 0; i < s.length(); i ++){
            if(s.charAt(i) == '(') ll.push(0);
            else{
                if(ll.size() > 1){
                    int count = ll.pop();
                    int sum = count + 1 + ll.pop();
                    max = max > sum ? max : sum;
                    ll.push(sum);
                }else{
                    ll.clear();
                    ll.push(0);
                }
            }
        }
        return max * 2;
    }
}

 第四遍：

public class Solution {
    public int longestValidParentheses(String s) {
        if(s == null || s.length() == 0) return 0;
        LinkedList<Integer> stack = new LinkedList<Integer>();
        stack.add(0);
        int result = 0;
        for(int i = 0; i < s.length(); i ++){
            if(s.charAt(i) == '(') stack.push(0);
            else{
                if(stack.size() > 1){
                    int tmp = stack.pop() + 2;
                    result = Math.max(result, tmp);
                    tmp += stack.pop();
                    stack.push(tmp);
                }else{
                    int tmp = stack.pop();
                    result = Math.max(result, tmp);
                    stack.push(0);
                }
            }
        }
        while(!stack.isEmpty()){
            result = Math.max(result, stack.pop());
        }
        return result;
    }
}