32. 最长有效括号(困难)-字节跳动高频题

一、题目描述

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

示例 1：

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

示例 2：

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

示例 3：

输入：s = ""
输出：0

二、解题

动态规划

动态规划主要思考两种问题，第一个边界条件，是否往前找时到达了前面的第一个字符；第二种是左右括号条件，如果当前括号为右括号，则判断前一个括号是否为左括号，然后结合边界条件，如果前面的括号是右括号，则判断他是否已经匹配了，如果匹配则继续往前找一位。

class Solution {
    public int longestValidParentheses(String s) {
        //动态规划
        int[] dp = new int[s.length()];
        int maxLength = 0;
        for(int i = 1;i<s.length();i++){
            //判断是够为右括号
            if(s.charAt(i) == ')'){
                //判断前面的括号是否为左括号
                if(s.charAt(i-1) == '('){
                    //边界条件判断
                    //1.如果前面的括号不是第一个括号
                    if(i-2>=0){
                        dp[i] = dp[i-2]+2;
                    }else{
                        //如果前面的括号是第一个括号，只能是两个括号,也是();
                        dp[i] = 2;
                    }
                }else if(i - dp[i - 1] > 0 && s.charAt(i - dp[i-1] -1) == '('){
                    //如果当前的括号为右括号 ....)) 也就是前面的括号也是正常的左右括号，继续向前找
                    //则需要判断前面的括号是否达到了边界的开始值
                    if(i - dp[i-1] - 2 >= 0){
                        //如果没有达到初始边界
                        dp[i] = dp[i-1] + 2 + dp[i-dp[i-1]-2];

                    }else{
                        dp[i] = dp[i-1] + 2;
                    }
                }
            }
            maxLength = Math.max(maxLength,dp[i]);
        }
        return maxLength;
    }
}

栈

• 对于遇到的每个 ‘(’ ，我们将它的下标放入栈中
• 对于遇到的每个‘)’ ，我们先弹出栈顶元素表示匹配了当前右括号：
  • 如果栈为空，说明当前的右括号为没有被匹配的右括号，我们将其下标放入栈中来更新我们之前提到的「最后一个没有被匹配的右括号的下标」
  • 如果栈不为空，当前右括号的下标减去栈顶元素即为「以该右括号为结尾的最长有效括号的长度」

class Solution {
    public int longestValidParentheses(String s) {
        //栈
        
        int maxLength = 0;
        Deque<Integer> stack = new LinkedList<>();
        stack.push(-1);
        for(int i = 0;i<s.length();i++){
            if(s.charAt(i) == '('){
                //如果是左括号 将下标存入栈中
                stack.push(i);
            }else{
                //如果是右括号 则出栈
                stack.pop();
                //如果栈为空
                if(stack.isEmpty()){
                    stack.push(i);
                }else{
                    maxLength = Math.max(maxLength,i-stack.peek());
                }
            }
        }
        return maxLength;       
    }
}

左右遍历

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