Leetcode 32 Longest Valid Parentheses

思路：brute force。暴力解法，找出所有的substring，然后判断是否valid。判断方法在Leetcode 20 Valid Parentheses。这里再介绍一种方法，用stack，遇到开括号push开括号，遇到闭括号pop在stack中的开括号。在这整个过程中，stack为空时，这时候再遇到闭括号，就直接返回false。或者过程结束后，stack中不为空，也返回false。除去了这两种情况，返回true。下面给出代码：

class Solution {
    
    //该方法没问题，但是time limit eceeded
    public int longestValidParentheses(String s) {
        
        //get all the substrings
        int len = s.length();
        int max = 0;
        for(int i = 0; i< len; i++){
            for(int j = i; j< len; j++){
                String str = s.substring(i,j+1);
                if(isValid(str)){
                    max = Math.max(max,j+1-i);
                }
            }
        }
        return max;

    }
    
    private boolean isValid(String s){
        int left = 0;
        int len = s.length();
        for(int i =0; i < len; i++){
            if(s.charAt(i)=='('){
                left++;
            }else{
                left--;
            }  
            if(left < 0){return false;}
        }
        return left == 0;
    }
}

上面这种方法会有大量的重复计算，例如")(()()"，在计算substring[0,5]时，又要计算前面的sunstring[0,2]，但是我们已经知道0-2是false了，那0-5肯定是false。碰到这种情况我们应该直接break。基于此，我们improve了上面的代码，时间复杂度也由n^3 to n ^2了。下面改进的代码：

public int longestValidParentheses(String s) {
    int count = 0;
    int max = 0;
    for (int i = 0; i < s.length(); i++) {
        count = 0;
        for (int j = i; j < s.length(); j++) {
            if (s.charAt(j) == '(') {
                count++;
            } else {
                count--;
            }
            if (count < 0) {
                break;

            }
            if (count == 0) {
                if (j - i + 1 > max) {
                    max = j - i + 1;
                }
            }
        }
    }
    return max;
}

最后介绍一个方法，dp，动态规划。我觉得dp就也是先找规律吧，找到规律就好写了。下面直接给出代码吧。具体思路解释可以看我bookmark里面收藏的一个人的主页，上面有详细的解释。下面直接给出代码：

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) == '(') {
                dp[i] = dp[i - 1] + ((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2;
            }
            maxans = Math.max(maxans, dp[i]);
        }
    }
    return maxans;
}

总结：

1. dp就是数学归纳，总结出通项，感觉其实和dfs有点相似，都需要找规律。我这里仅指他们都需要找规律，还这点相似，其他没啥相似的了。dfs是和tree有关的。