LeetCode（32.最长有效括号）

题目

给你一个只包含 ‘(’ 和 ‘)’ 的字符串，找出最长有效（格式正确且连续）括号子串的长度。

示例 1：

输入：s = “(()”
输出：2
解释：最长有效括号子串是 “()”
示例 2：

输入：s = “)()())”
输出：4
解释：最长有效括号子串是 “()()”
示例 3：

输入：s = “”
输出：0

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-valid-parentheses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解

1. 有重复计算的方法

int longestValidParentheses(string s) {
    int max = 0;
    for(int i = 0;i<s.length();){
        int judge = 0,n = 0;
        for(int j = i;j<s.length();j++){
            if(s[j]== '('){
                judge++;
            }else{
                judge--;
            }
            if(judge<0){
                break;
            } else if (judge==0){
                n = j-i+1;
            }
        }
        if(n>max){
            max = n;
        }
        if(n){
            i+=n;
        }else{
            i++;
        }
    }
    return max;
}

在极端情况下有重复的计算，“（（（（（（（（”，时间复杂度为N2
2. 动态规划

int longestValidParentheses(string s) {
    int dp[s.length()];
    for (int i = 0; i < s.length(); i++) {
        dp[i] = 0;
    }
    int max = 0;
    for (int i = 1; i < s.length(); i++) {
        if (s[i] == ')') {
            if (s[i - 1] == '(') {//()
                dp[i] = i > 1 ? 2 + dp[i - 2] : 2;
            } else if (i > 1 && dp[i - 1]) {//))的情况
                int j = i - dp[i - 1] - 1;
                if ((j >= 0) && (s[j] == '(')) {//(有效括号)
                    dp[i] = j - 1 >= 0 ? dp[i - 1] + 2 + dp[j - 1] : dp[i - 1] + 2;//有效括号(有效括号)
                }
            }
        }
        max = max < dp[i] ? dp[i] : max;
    }
    return max;
}

3. 栈

int longestValidParentheses(string s) {
    stack<int> st;
    st.push(-1);//括号从0处开始
    int max = 0, length = 0;
    for (int i = 0; i < s.length(); i++) {
        if (s[i] == '(') {
            st.push(i);
        } else {
            st.pop();
            if (st.empty()) {//截断了最长括号
                st.push(i);
            } else {//此时括号马原结束
                length = i - st.top();
            }
        }
        max = max < length ? length : max;
    }
    return max;
}

4. 正逆方向

int longestValidParentheses(string s) {
    int left_num = 0, right_num = 0;
    int max = 0, length = 0;
    for (int i = 0; i < s.length(); i++) {//正向循环
        if (s[i] == '(') {
            left_num++;
        } else {
            right_num++;
        }
        if (right_num > left_num) {
            right_num = 0;
            left_num = 0;
        } else if (right_num == left_num) {
            length = right_num * 2;
            max = max < length ? length : max;
        }

    }
    left_num = 0, right_num = 0, length = 0;
    for (int i = s.length(); i; i--) {//逆向循环
        if (s[i] == ')') {
            right_num++;
        } else {
            left_num++;
        }
        if (left_num > right_num) {
            right_num = 0;
            left_num = 0;
        } else if (right_num == left_num) {
            length = right_num * 2;
            max = max < length ? length : max;
        }
    }
    return max;
}

单层循环可能会丢掉正确答案；
双层循环可以互补，万无一失。