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.

思路一：

比较笨的方法。借助栈进行括号的匹配，栈中存储的是字符在字符串中的位置，借助一个与字符串相同长度的数据来记录哪些字符是被匹配过的，扫描过一遍字符串之后，再扫描一遍数组，便可得出最长的有效括号序列。

public int longestValidParentheses(String s) {
        if(s == null || s.length() == 1) {
            return 0;
        }
        int[] mark = new int[s.length()];
        Stack<Integer> stack = new Stack<Integer>();
        for(int i=0; i<s.length(); i++) {
            if(stack.isEmpty()) {
                stack.push(i);
                continue;
            }
            int top = stack.peek();
            if(s.charAt(top) == '(' && s.charAt(i) == ')') {
                stack.pop();
                mark[top] = 1;
                mark[i] = 1;
            } else {
                stack.push(i);
            }
        }
        int ret = 0;
        int count = 0;
        for(int i=0; i<mark.length; i++) {
            if(mark[i] == 1) {
                count++;
                ret = Math.max(ret, count);
            } else {
                count = 0;
            }
        }
        return ret;
    }

思路二：

也是借用栈，但是栈中只保存'('。

tmp表示当前计算的一套完整的括号集的长度，完整是指消耗掉栈中所有的'('

sum表示几个连续的完整括号集的总长。

当出现不完整的括号集，需要独立拿出来计算，作为一个阶段性的结果，这时已匹配括号集的长度是当前字符所在位置与栈顶元素之差。

当栈为空时，出现一个')'，说明之前的括号集与下一个括号集之间已不连续，sum需要置0。

public int longestValidParenthesesII(String s) {
        if(s == null || s.length() == 1) {
            return 0;
        }
        Stack<Integer> stack = new Stack<Integer>();
        int ret = 0;
        int sum = 0;
        for(int i=0; i<s.length(); i++) {
            char ch = s.charAt(i);
            if(ch == '(') {
                stack.push(i);
            } else {
                if(stack.isEmpty()) {
                    // 栈中没有'(',出现')'
                    sum = 0;
                    continue;
                }
                int tmp = i - stack.pop() + 1;
                if(stack.isEmpty()) {
                    // 有一套完整的括号集，可以加到前面的一整套括号集上
                    sum += tmp;
                    ret = Math.max(ret, sum);
                } else {
                    // 可能是一个未完成的括号集, 计算阶段性的结果
                    tmp = i - stack.peek();
                    ret = Math.max(ret, tmp);
                }
            }
        }
        return ret;
    }