【Leetcode】32. 最长有效括号

题目

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

示例 1:

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

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

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

解法

方法1

使用动态规划解决此问题。dp[i]表示已索引为i结尾的字符串的有效括号长度。

当s.charAt(i)=='('，表示已i为结尾的字符串不是有效括号，则dp[i] = 0

当s.charAt(i)==')':

         当s.charAt(i-1)=='('时，dp[i] = 2 + dp[i-2]。这是因为i和i-1组成了一个有效括号，长度为2，再加上已i-2为结尾的有效括号长度

        当s.charAt(i-1)==')'，如果s.charAt([i-1-dp[i-1]]) == ')' 则表示i没有对应的左括号，所以dp[i] == 0

        当s.charAt(i-1)==')'，如果s.charAt([i-1-dp[i-1]) == '('，则i和i-1-dp[i-1]]组成了一个括号对，所以dp[i] = 1 + dp[i-1] + 1 + dp[i-1-dp[i-1] -1]。

注意做一下越界的检测，时间复杂度为O(N)，空间复杂度为O(N)

class Solution {
    public int longestValidParentheses(String s) {
        char[] cs = s.toCharArray();
        int[] dp = new int[cs.length];
        int max = 0;
        for(int i = 1; i < cs.length; i++){
            char cr = cs[i];

            if(cr == '('){
                dp[i] = 0;
            }else{
                if(cs[i-1] == '('){
                    dp[i] = 2 + (i - 2 > 0 ? dp[i-2] : 0);
                }else{
                    if(dp[i-1] <= i - 1 && cs[i-1 - dp[i-1]] == '('){
                        dp[i] = 2 + dp[i-1] + (dp[i-1] <= i-2 ? dp[i-2 -dp[i-1]] : 0);
                    }else{
                        dp[i] = 0;
                    }
                }
            }
            max = Math.max(max,  dp[i]);
        }


        return max;
    }
}

方法2

class Solution {
    public int longestValidParentheses(String s) {
        Stack<Integer> stack = new Stack();
        stack.push(-1);
        int max = 0;
        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{
                    max = Math.max(max, i - stack.peek());
                }
            }
        }

        return max;
    }
}

方法3

class Solution {
    public int longestValidParentheses(String s) {
       
        return Math.max(longestValidParentheses(s, true), longestValidParentheses(s, false));
    }

    public int longestValidParentheses(String s, boolean isLeft){
        char[] cs = s.toCharArray();
        int max = 0;
        int left = 0;
        int right = 0;
        char flag = '(';
        if(!isLeft){
            flag = ')';
        }
        for(int i = 0; i < cs.length; i++){
            char tmp;

            if(!isLeft){
                tmp = cs[cs.length - 1 - i];
            }else{
                tmp = cs[i];
            }
            
            if(tmp == flag){
                left++;
            }else{
                right++;
            }
            if(right > left){
                left = 0;
                right = 0;
            }
            if(left == right){
                max = Math.max(max, right * 2);
            }
        }
        
        return max;
    }

}