32. Longest Valid Parentheses

32. Longest Valid Parentheses

    本题解采用了三种方法，分别为常规动态规划、遍历方向匹配和动态规划栈，其中方法一时间复杂度过大，不能完全AC，会超时，不想看的同志可以忽略；方法二算法简单，容易理解，速度慢，可以AC；方法三为方法二的进阶，稍难一点（其实看了二以后就不太难了），速度较快。

常规动态规划：

dp[i][j] 表示从 i 到 j 之间有效

初始时：dp[i][i+1] = (s[i] == '(' && s[j] == ')' );

状态转移，长度 len 从 2 变到 str.size() ，对于 长度为 len 的子串作以下判断。

    1. 假如其子串 dp[i+1][j-1] 有效且 s[i] = '(' && s[j] == ')' ，则 dp[i][j] 有效，形如 '(...)' ；

    2. 假如其子串 dp[i+k] 和 dp[k+1][j] 皆有效，则其有效，形如'()()', '(())()' ；

具体细节见代码：

class Solution {
public:
    int longestValidParentheses(string s) {
        int strlen = s.size();
        if(strlen < 2){
            return 0;
        }
        int maxlen = 0;
        vector< vector<bool> > dp(strlen, vector<bool>(strlen));
        for(int i = 0; i < strlen; i++){
            dp[i][i] = true; // 空串为正确
            if(i+1 < strlen && s[i+1] == ')' && s[i] == '('){
                // () 为正确
                dp[i][i+1] = true;
                maxlen = 2;
            }
        }
        for(int len = 4; len <= strlen; len+=2){
            for(int i = 0; i < strlen - len + 1; i++){
                int j = i + len - 1;
                if(dp[i+1][j-1] && s[i] == '(' && s[j] == ')'){
                    // 当为 (...)情况时，如 (()), (()()) 等时
                    dp[i][j] = true;
                    maxlen = max(maxlen, len);
                }
                else{
                    dp[i][j] = false;
                    for(int k = 1; k < len; k+=2){
                        // k+=2 保证 i~i+k具有偶数个长度k+1
                        if(dp[i][i+k] && dp[i+k+1][j]){
                            dp[i][j] = true;
                            maxlen = max(maxlen, len);
                            break;
                        }
                    }
                }
            }
        }
        return maxlen;
    }
};

令人沮丧的是，此方法会超时，218/230 通过，看题解发现另一种很新奇的思路，dp + 栈

，在看这个方法以前，看一个更简单的方法，暂且称之为遍历匹配法，此办法比较简单，速度也较慢。

遍历反向匹配法：

思路：

    1. 将子串长度的状态栏置为 0;

    2. 遍历子串，遇到 ')' 则向前匹配 '(' ,遇到未匹配的 '(' 则置其状态为 1，并置本状态为 2；

    3. 状态栏的最长 >=1 序列即为匹配序列；

class Solution {
public:
    int longestValidParentheses(string s) {
        int strlen = s.size();
        if(strlen < 2){
            return 0;
        }
        int maxlen = 0;
        vector<int> state(strlen);
        for(int i = 0; i < strlen; i++){
            //state[i] = 0;
            if(s[i] == ')'){
                for(int j = i-1; j >= 0; j--){
                    if(s[j] == '(' &&  state[j] == 0){
                        state[j] = 1;
                        state[i] = 2;
                        break;
                    }
                }
            }
        }
        int len = 0;
        for(int i = 0; i < strlen; i++){
            if(state[i]){
                len++;
            }
            else{
                maxlen = max(maxlen, len);
                len = 0;
            }
        }
        maxlen = max(maxlen, len);
        return maxlen;
    }
};

考虑向前匹配可使用栈来实现，则成为动态规划 + 栈的结合。

动态规划 + 栈：

栈匹配：

    1. 遍历子串，maxlen 记录最大连续匹配串，dp[i] 记录以 i 开始的最大串个数，初始均为 0 ；

    2. 如果为 '('， 则压入其 index i ；

        若为 ')'，且栈非空，则取出栈顶 index j，表明此 ')' 与 i 对应的 '(' 匹配，则 dp[j] 在其原来的数量 + 1, 并将当前栈顶元素的 index（假如存在的话 ）对应的dp[stk.top()]+=dp[i[  ，表明栈顶 '(' 对应的最大串长度包含刚刚被匹配掉的 '(' 所拥有的个数，如果栈空，即不存在，则需要top += dp[j]， top 是在整个字符串都被匹配掉时作用，可以理解为 i = -1时， i = 0 为第一个字符；

        若为 ')'，且栈为空，将 top 的值保留并重置其为 0；

    3. 遍历 top 和 dp[i] 得到最大次数

class Solution {
public:
    int longestValidParentheses(string s) {
        int strlen = s.size();
        if(strlen < 2){
            return 0;
        }
        int maxlen = 0;
        stack<int> stk;
        vector<int> dp(strlen);
        int top = 0;
        for(int i = 0; i < strlen; i++){
            if(s[i] == '('){
                stk.push(i);
            }
            else if(!stk.empty()){
                int j = stk.top();
                stk.pop();
                dp[j]++;
                if(!stk.empty()){
                    dp[stk.top()]+=dp[j];
                }
                else{
                    top+=dp[j];
                }
            }
            else{
                maxlen = max(maxlen, top);
                top = 0;
            }
        }
        maxlen = max(maxlen, top);
        for(int i = 0; i < strlen; i++){
            maxlen = max(maxlen, dp[i]);
        }
        return maxlen*2;
    }
};