👉️ 力扣原文

题目

给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。

示例

输入：s = "(()"
输出：2
解释：最长有效括号子串是 "()"

输入：s = ")()())"
输出：4
解释：最长有效括号子串是 "()()"

输入：s = ""
输出：0

输入：s = "(())("
输出：4

分析思路1

用栈的解法：

1. 定义一个栈，用于存储字符在字符串中的下标。初始化时，将-1压入栈中。
2. 从字符串的左边开始遍历，如果遇到左括号，则将其下标压入栈中。
3. 如果遇到右括号，则弹出栈顶元素，表示与该右括号匹配的左括号已经找到。如果此时栈为空，则将该右括号的下标压入栈中，表示该右括号没有匹配的左括号。
4. 如果栈不为空，则计算当前子串的长度，即当前右括号的下标减去栈顶元素的值。如果该子串的长度大于最长子串的长度，则更新最长子串的长度。

题解1

class Solution {
    public int longestValidParentheses(String s) {
        int maxLen = 0;
        Stack<Integer> stack = new Stack<>();
        stack.push(-1);//有效括号长度为当前右括号下标减去栈底元素,初始化要是-1才对
        for (int i=0; i<s.length(); i++){
            char c = s.charAt(i);
            if(c == '('){
                stack.push(i);
            }else {
                stack.pop();//弹出栈顶
                if(stack.isEmpty()){ // 栈为空，说明当前右括号没有与之匹配的左括号
                    stack.push(i);// 将当前右括号下标压入栈中
                }else {// 栈不为空，计算有效括号长度
                    int len = i - stack.peek();
                    maxLen = Math.max(maxLen, len);
                }
            }
        }
        return maxLen;
    }

}

执行结果

分析思路2

双指针：
在此方法中，我们利用两个计数器 left 和 right 。首先，我们从左到右遍历字符串，对于遇到的每个 ‘(’，我们增加 left 计数器，对于遇到的每个 ‘)’ ，我们增加 right 计数器。每当 left 计数器与 right 计数器相等时，我们计算当前有效字符串的长度，并且记录目前为止找到的最长子字符串。当 right 计数器比 left 计数器大时，我们将 left 和 right 计数器同时变回 0。

这样的做法贪心地考虑了以当前字符下标结尾的有效括号长度，每次当右括号数量多于左括号数量的时候之前的字符我们都扔掉不再考虑，重新从下一个字符开始计算，但这样会漏掉一种情况，就是遍历的时候左括号的数量始终大于右括号的数量，即 (() ，这种时候最长有效括号是求不出来的。

解决的方法也很简单，我们只需要从右往左遍历用类似的方法计算即可，只是这个时候判断条件反了过来：

当left 计数器比right 计数器大时，我们将left 和 right 计数器同时变回 0
当 left 计数器与 right 计数器相等时，我们计算当前有效字符串的长度，并且记录目前为止找到的最长子字符串
这样我们就能涵盖所有情况从而求解出答案。

题解2

class Solution {
    public int longestValidParentheses(String s) {
        int left=0,right=0,maxLen=0;
        for (int i = 0; i < s.length(); i++) {
            if(s.charAt(i)=='('){
                left++;
            }else {
                right++;
            }
            if(left == right){
                maxLen = Math.max(maxLen, right*2);
            }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){
                maxLen = Math.max(maxLen, right*2);
            }else if(left > right){
                left = right = 0;
            }
        }
        return maxLen;
    }

}

执行结果

分析思路3

使用动态规划：
我们定义一个一维数组 dp，其中 dp[i] 表示以 i 位置结尾的有效括号子串的最长长度。在计算 dp[i] 时，我们需要根据 s[i] 的值进行分类讨论：

1.当 s[i] 为左括号 ‘(’ 时，以 i 位置结尾的子串肯定不是有效括号子串，因此 dp[i] = 0。
2.当 s[i] 为右括号 ‘)’ 时，我们需要找到与其匹配的左括号。具体来说，我们可以先计算前面已经形成的有效括号长度 preLen，然后在 i - preLen - 1 的位置寻找与当前的右括号相匹配的左括号，即 s[pre]。如果 s[pre] 为左括号，则当前的右括号可以与其闭合，有效长度增加2。此时，我们还需要再往前看一眼，是否还有有效长度，如果有，合并过来。例如：“()(()())” 当前在计算最后一个位置时，dp[7] 已经等于 dp[6]+2 = 4+2，但需要再往前看一眼，dp[1] 还有有效长度，合并过来 dp[7] = 4+2+2。那是否还需要再往前看？不需要了，因为，如果前面还有有效长度，其长度肯定已经合并到 dp[2] 上了。因此，每次只需要再往前多看一眼就可以。

最终答案是 dp 数组中的最大值。

题解3

class Solution {
    // 子串问题：严格以每个结尾计算个答案，最终答案必在其中
    public static int longestValidParentheses(String s) {
        if (s == null || s.length() < 2) return 0;

        int[] dp = new int[s.length()]; // dp[i]：严格以i位置结尾，形成的有效括号子串最长长度是多少
        int max = 0; // 最终的答案

        // dp[0] = 0; // 默认

        for (int i = 1; i < s.length(); i++) {
            // if (s.charAt(i) == '(') dp[i] = 0; 以左括号结尾，无效
            
            if (s.charAt(i) == ')') {
                int preLen = dp[i - 1]; // 前面已经形成的有效括号长度
                int pre = i - 1 - preLen; // 寻找与当前的右括号相匹配的左括号位置：前面有效括号长度再往前一个位置

                if (pre >= 0 && s.charAt(pre) == '(') { // 如果寻找到左括号：前面有效括号长度再往前一个位置是左括号
                    dp[i] = dp[i-1] + 2; // 可以与当前的右括号闭合，有效长度增加2

                    // 【注意】此时，需要再往前看下，是否还有有效长度，如果有，合并过来
                    // 例如："()(()())" 当前在计算最后一个位置时，dp[7]已经等于 dp[6]+2 = 4+2
                    // 但需要再往前看一眼，dp[1]还有有效长度，合并过来 dp[7] = 4+2+2
                    // 那是否还需要再往前看？
                    // 不需要了，因为，如果前面还有有效长度，其长度肯定已经合并到dp[2]上了
                    // 因此，每次只需要再往前多看一眼就可以
                    if (pre-1 >= 0) {
                        dp[i] += dp[pre-1];
                    }
                }

                max = Math.max(max, dp[i]); // 严格以每个结尾抓一个答案，最终答案必在其中
            }
        }

        return max;
    }

}

执行结果