每日一道算法题——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.

分析

题目就是要我们求出最长合法圆括号的长度，但是我们要明确几点，举几个例子就明白了。)()(()))这个最长的合法括号是()(())，长度为6，所以相邻的括号对是可以看成是一组的。

算法

1. 最直接的就是暴力求解，求出所有的可能

"((())"

(( --> invalid
(( --> invalid
() --> valid, length=2
)) --> invalid
((()--> invalid
(())--> valid, length=4
maxlength=4

public class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<Character>();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                stack.push('(');
            } else if (!stack.empty() && stack.peek() == '(') {
                stack.pop();
            } else {
                return false;
            }
        }
        return stack.empty();
    }
    public int longestValidParentheses(String s) {
        int maxlen = 0;
        for (int i = 0; i < s.length(); i++) {
            for (int j = i + 2; j <= s.length(); j+=2) {
                if (isValid(s.substring(i, j))) {
                    maxlen = Math.max(maxlen, j - i);
                }
            }
        }
        return maxlen;
    }
}

时间复杂度为O(n^3)

2.动态规划
用一个一维数组dp[]来存储当前元素匹配的长度。
如果s[i] ==')' && s[i-1] == '('，那么 dp[i] = dp[i-2] +2,因为要加上相邻的括号对（如果有的话），例如：()()()，那么dp={0,2,0,4,0,6}
如果s[i] == ')' && s[i-1] ==')'，如果s[i - dp[i-1] -1 ] = '('（例如(())这种情况），那么dp[i]=dp[i-1] + dp[i-dp[i-1]-2] +2例如()(())，我们要判断左边是否有相邻的括号。所以最终dp={0,2,0,0,2,6}

public class Solution {
    public int longestValidParentheses(String s) {
        int maxans = 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 ? dp[i - 2] : 0) + 2;
                } else if (i - dp[i - 1] > 0 &&
                 s.charAt(i - dp[i - 1] - 1) == '(') {
((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2;
                }
                maxans = Math.max(maxans, dp[i]);
            }
        }
        return maxans;
    }
}

时间复杂度为O(n)
下面这个动画应该能够帮助理解。

3. 利用栈
我们不是把括号压入栈中，而是把括号对应的下标压栈。看下面的动画：

代码：

public class Solution {

    public int longestValidParentheses(String s) {
        int maxans = 0;
        Stack<Integer> stack = new Stack<>();
        stack.push(-1);
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                stack.push(i);
            } else {
                stack.pop();
                if (stack.empty()) {
                    stack.push(i);
                } else {
                    maxans = Math.max(maxans, i - stack.peek());
                }
            }
        }
        return maxans;
    }
}

时间复杂度为O(n)