[leetcode]Longest Valid Parentheses

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.

算法:

思路1 ：dp，感觉这道题略坑爹啊，还是屡一下思路吧，毕竟对DP完全不熟悉。

维护一个s.length()一维数组，dp，其中dp[i]表示从索引i到末尾所组成字符串的前缀最长的有效括号组合的长度。

例如：)()，则为0，而非2；())()，为2，表示的是前面的()

因此：dp[s.length() - 1] = 0;从后向前逆向求解dp[i]，

1. 如果s[i]=')'，则显然dp[i]=0;（均不合法）
2. 如果s[i]='('，跳过dp[i+1]这段长度从j=i+1+dp[i+1]开始（找到最长前缀的后驱），如果j没越界并且s[j]=')'，正好和s[i]匹配（组成了dp[i]的合法最长前缀），则dp[i]=dp[i+1]+2；另外此时可能j之后的也可以连上，所以，可能要加上dp[j+1];

代码如下：

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

思路2： 这个思路有点吊，算法具体思想是，先把所有匹配的括号对，变成一样的标记，比如‘0’，例如：)()()()(()变成)000000(00，这样再求是不是容易多了？方法很巧妙，可惜时间复杂度略高，达到了O(n*n)

代码如下：

public class Solution {
    public int longestValidParentheses(String s) {
        if(s == null || s.length() < 2) return 0;
        char[] charArray = s.toCharArray();
        for(int i = 0; i < s.length(); i++){
            char c = charArray[i];
            if(c == ')'){
                for(int j = i - 1; j >= 0; j--){
                    if(charArray[j] == '0') continue;
                    if(charArray[j] == '('){
                        charArray[i] = charArray[j] = '0';
                    }
                        break;
                }
            }
        }
        int max = 0;
        for(int i = 0; i < s.length(); i++){
            if(charArray[i] == '0'){
                int begin = i;
                while(i < charArray.length && charArray[i] == '0') i++;
                max = Math.max(max,i - begin);
            }
        }
        return max;
    }
}

第二遍记录：

同样采用了DP。

与上面的思路1恰恰相反：这里将dp[i]表示以s[i]为结尾的字符串的后缀的最长合法长度；

状态转移方程：(为了方便，假设下面的指针都是合法的)

1. 当s[i] = '(' 时，显然不需要处理，dp[i] = 0

2. 当s[i] = ')' 时，此时s[i - 1] 有两种情况

2.1 s[i - 1] = '('。表示s[i]匹配成功，要验证dp[i - 2]的状态，以判断是否可以与前面的相连

2.2 s[i - 1] = ')'。表示s[i]并不一定能匹配成功，要验证dp[i - dp[i - 1] - 2] 的状态。

其实这个思路不需要看的，跟上面的思路1一样。有兴趣可以看下：

public class Solution {
    public int longestValidParentheses(String s) {
        if(s == null || s.length() < 2) return 0;
        int max = 0,length = s.length();
        char[] sc = s.toCharArray();
        int[] dp = new int[length];
        Stack<Character> stack = new Stack<Character>();
        for(int i = 1; i < length; i++){
            if(sc[i] == '(') continue;
            if(sc[i - 1] == '('){
                dp[i] = 2;
                if(i - 2 >= 0) dp[i] += dp[i - 2];
            }else{
                if(dp[i - 1] > 0){
                    int leap = dp[i - 1];
                    if(i - 1 - leap >= 0 && sc[i - 1 - leap] == '('){
                        dp[i] = dp[i - 1] + 2;
                        if(i - leap - 2 >= 0) dp[i] += dp[i - leap - 2];
                    }
                }
            }
            max = Math.max(max,dp[i]);
        }
        return max;
    }
}