LeetCode Longest Valid Parentheses

原题链接在这里：https://leetcode.com/problems/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.

题解：

和Largest Rectangle in Histogram都是往栈内存index. 

这道题是求最长的括号序列，比较容易想到用栈这个数据结构。基本思路就是维护一个栈，遇到左括号就进栈，遇到右括号则出栈，并且判断当前合法序列是否为最 长序列。不过这道题看似思路简单，但是有许多比较刁钻的测试集。具体来说，主要问题就是遇到右括号时如何判断当前的合法序列的长度。比较健壮的方式如下：
(1) 如果当前栈为空，则说明加上当前右括号没有合法序列（有也是之前判断过的）；
(2) 否则弹出栈顶元素，如果弹出后栈为空，则说明当前括号匹配，我们会维护一个合法开始的起点start, 合法序列的长度即为当前元素的位置 i-start+1; 否则如果栈内仍有元素，那肯定是"(". 合法序列就会从这个"("下一位开始. 长度为当前栈顶元素的位置的下一位到当前元素的距离. i-(stk.peek()+1)+1. 因为栈顶元素后面的括号对肯定是合法的, 而 且左括号出过栈了。

Time Complexity: O(n). Space: O(n).

AC Java:

public class Solution {
    public int longestValidParentheses(String s) {
        if(s == null || s.length() == 0){
            return 0;
        }
        
        int res = 0;
        int start = 0;
        
        Stack<Integer> stk = new Stack<Integer>();
        for(int i = 0; i<s.length(); i++){
            if(s.charAt(i) == '('){
                stk.push(i);
            }else{
                //遇到')',但是stack是空的，说明不合法，更新 start 到 i+1
                if(stk.isEmpty()){
                    start = i+1;
                }else{
                    //否则弹出栈顶
                    stk.pop();
                    //剩下的stack为空，说明到start 到 i是合法括号对
                    if(stk.isEmpty()){
                        res = Math.max(res, i-start+1);
                    }else{
                    //身下的stack不为空，说明当前stack的栈顶 后面的括号对才是合法的
                        res = Math.max(res, i-stk.peek());
                    }
                }
            }
        }
        return res;
    }
}

可以利用DP. 求最长的valid parentheses. 需要储存的历史信息是到当前位最长valid parentheses 长度.

状态转移, 若当前是")". 看当前括号的前一个括号的匹配情况，例如在7之前以6结尾的的最佳匹配是3-6, 看3之前的括号和7是否匹配，不匹配则没有变化; 而6之前以5结尾的最佳匹配是4-5, 此时3和6匹配, 则dp[i]+2.

此外，如果与当前括号匹配的左括号之前的括号的dp值也应该加进来，因为由于添加了当前的括号，那些括号也被连接起来了。例如3和6匹配后, 1和2也应该被加到以6结尾的最佳匹配中.

)  (  )  (  (  )  )  )

0 1 2 3 4 5 6 7

Time Complexity: O(s.length()).

Space: O(s.length()).

AC Java:

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

 也可以节省空间. 

分别计数遇到的"(" 和")"的个数l 和 r. 先从左向右扫, l == r时跟新维护res. 当r大于l 时不合法重置为0.

在反过来从右向左扫一次.

为什么不能一次呢. e.g. ()((). 中间出现不合法, 若最后及时r比l小, 但取出r*2. 答案就是4. 正解应该是2.

Time Complexity: O(s.length()). Space: O(1).

AC Java:

class Solution {
    public int longestValidParentheses(String s) {
        if(s == null || s.length() == 0){
            return 0;
        }
        
        int res = 0;
        int l = 0;
        int r = 0;
        for(int i = 0; i<s.length(); i++){
            if(s.charAt(i) == '('){
                l++;
            }else{
                r++;
            }
            
            if(l == r){
                res = Math.max(res, r*2);
            }else if(r > l){
                l = 0;
                r = 0;
            }
        }
        
        l = 0; 
        r = 0;
        for(int i = s.length()-1; i>=0; i--){
            if(s.charAt(i) == '('){
                l++;
            }else{
                r++;
            }
            
            if(l == r){
                res = Math.max(res, r*2);
            }else if(l > r){
                l = 0;
                r = 0;
            }
        }
        return res;
    }
}