[LeetCode] Longest Valid Parentheses -- 挂动态规划羊头卖stack的狗肉

(Version 1.3)

这题在LeetCode上的标签比较有欺骗性，虽然标签写着有DP，但是实际上根本不需要使用动态规划，相反的，使用动态规划反而会在LeetCode OJ上面超时。这题正确的做法应该和Largest Rectangle in Histogram那几个使用stack来记录并寻找左边界的题比较类似，因为在仔细分析问题并上手尝试解决时，会发现问题的关键在于怎么判定一个valid parentheses子串的起始位置，或者说当遇到一个')'时，怎么知道要加到哪里去。

 

第一次做的时候因为标签是DP，所以写了一个无脑版本的DP，时间复杂度是O(N^2)的，结果不出意料得到了Time Limit Exceeded，代码如下，

public class Solution {
    public int longestValidParentheses(String s) {
        if (s.length() < 2) {
            return 0;
        }
        int result = 0;
        boolean[][] isValid = new boolean[s.length()][s.length()];
        int len = s.length();
        for (int i = 0; i < isValid.length - 1; i++) {
            if (s.charAt(i) == '(' && s.charAt(i + 1) == ')') {
                isValid[i][i + 1] = true;
                result = 2;
            }
        }
        for (int l = 4; l <= len; l += 2) {
            int bound = len - l;
            for (int i = 0; i <= bound; i++) {
                int j = i + l - 1;
                isValid[i][j] = (isValid[i + 1][j - 1] && s.charAt(i) == '(' && s.charAt(j) == ')') 
                        || (isValid[i][j - 2] && s.charAt(j - 1) == '(' && s.charAt(j) == ')') 
                        || (isValid[i + 2][j] && s.charAt(i) == '(' && s.charAt(i + 1) == ')');
                if (isValid[i][j] && l > result) {
                    result = l;
                }
            }
        }
        return result;
    }
}

 

于是忽然意识到这题既然是求substring而不是subsequence，没准可以不用DP来做，因为substring的话感觉好像并不会有很多overlapping的subproblem，而是可以不断地明确砍掉已经处理过的substring进而缩小问题范围，于是想到了依然采用类似Valid Parentheses的计数的方法，用O(N)的时间复杂度和O(1)的空间复杂度就可以解决，代码如下：

public class Solution {
    public int longestValidParentheses(String s) {
        if (s.length() < 2) {
            return 0;
        }
        int result = 0;
        int count = 0;
        int diff = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                count++;
                diff++;
            } else {
                diff--;
                if (diff < 0) {
                    diff = 0;
                    count = 0;
                } else if (diff == 0 && result < (count << 1)) {
                    result = count << 1;
                }
            }
        }
        count = 0;
        diff = 0;
        for (int i = s.length() - 1; i >= 0; i--) {
            if (s.charAt(i) == ')') {
                count++;
                diff++;
            } else {
                diff--;
                if (diff < 0) {
                    diff = 0;
                    count = 0;
                } else if (diff == 0 && result < (count << 1)) {
                    result = count << 1;
                }
            }
        }
        return result;
    }
}

其中用右移一位运算代替了乘2，纯属个人爱好，可能不是一个好的代码习惯。这个代买的思路是先从左向右走一次，每当发现所有在考虑的左右括号完全匹配（即diff == 0时）尝试更新result。第一次走下来如果左括号一直多于右括号的话就无法得到答案，所以再从右到左走一次，这样两次当中可以确保至少有一次能够使得diff == 0，以取得正确答案。

这一版本的答案是由于之前一直在思考DP的做法而产生的，如果向Valid Parentheses的解法靠拢尝试使用stack的话应该会有使用额外空间但是只需要扫一次的解法。

 

下面是重写的code ganker的解法（http://blog.csdn.net/linhuanmars/article/details/20439613），思路主要是：类似Valid Parentheses，用一个stack按顺序记录'('的index，再用一个变量记录当前可能的substring的开头。每当遇到一个')'时，若stack非空，则pop出一个元素，若pop之后非空，说明当前只能匹配到上一个尚未被匹配的'('，即stack.peek()；若stack为空，说明可以一直匹配到start。当发现')'多于'('时，即在遇到')'时stack为空，则需要移动start到至少最后一个')'的下一位，因为易得当')'多于'('时，不可能再继续append到之前的任何substring得到依然valid的，所以可以砍掉前面的东西，缩小需要考虑的范围。代码如下：

public class Solution {
    public int longestValidParentheses(String s) {
        Stack<Integer> stack = new Stack<>();
        int result = 0;
        int start = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                stack.push(i);
            } else {
                if (!stack.isEmpty()) {
                    stack.pop();
                    result = stack.isEmpty() ? Math.max(result, i - start + 1) : Math.max(result, i - stack.peek());
                } else {
                    start = i + 1;
                }
            }
        }
        
        return result;
    }
}

 

这个解法的关键insight在于理解用stack存index的真正目的是记录可能的substring左边界，用于在找到一个')'判断左边界应该在哪，值得集中练习掌握，LeetCode上面相关的题目还有上面提到的Largest Rectangle in Histogram，Trapping Rain Water等。