9. LeetCode 32：最长有效括号

给定一个只包含 ‘(’ 和 ‘)’ 的字符串，找出最长的包含有效括号的子串的长度。

示例 1:

输入: “(()” 输出: 2 解释: 最长有效括号子串为 “()” 示例 2:

输入: “)()())” 输出: 4 解释: 最长有效括号子串为 “()()”

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-valid-parentheses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法1：动态规划（O(n)）

$dp[i]$表示以下标为i结尾的最长有效括号串长度：

• 第一种情况，第i个字符和第i-1个字符恰好组成一对括号，即 $\ ...()$，则有 $dp[i]=dp[i-2]+2$
• 第二种情况，第i个字符和第 $(i-1-dp[i-1])$个字符组成一对括号，即 $\ (...))$，则有$ dp[i]=dp[i−1]+2+dp[i−dp[i−1]−2]$

代码：

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

解法2：栈（思路更清晰）

遇到$\ (\ $则将其下标入栈，遇到$\ )\ $出栈，并将当前元素下标与栈顶值相减。

class Solution {
    public int longestValidParentheses(String s) {
        if(s==null||s.length()<2){
            return 0;
        }
        Stack<Integer> stack = new Stack<>();
        stack.push(-1);
        int idx = 0;
        int res = 0;
        while(idx<s.length()){
            if(s.charAt(idx)=='('){
                stack.push(idx);
            }else{
                stack.pop();
                if(stack.isEmpty()){
                    stack.push(idx);
                }else{
                    res = Math.max(res,idx-stack.peek());
                }
            }
            idx++;
        }
        return res;
    }
}

解法三：双指针（空间最优解）

用Left和Right两个指针标记左右括号的个数，个数相等说明成对了。

• 从左向右扫描时，Left<Right，则清零

• 从右向左扫描时，Left>Right，则清零

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

总结

第一种解法：动态规划，提前建立数组，找好规律，后续只是赋值，速度最快
第二种解法：思路最清晰，但涉及栈的操作，Stack继承自Vector，出入栈底层涉及扩容，新建数组，数组值的复制，效率会低。（可以考虑初始化时确定容量）
第三种解法：由于有两段循环，时间上要比第一种略高，但空间上从O(n)优化到O(1)，还是值得学习的。