[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等。