[LeetCode P32] Longest Valid Parentheses 四种解法

又是一道Hard题，但AC却很简单，用暴力算法，大概5-10分钟就搞定了，比较难的是这题有很多种解法，把这些解法都理解一遍比较好。四种解法都做了注释，而且代码很短，可以直接往下看。

/*
原题：
Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring.

For "(()", the longest valid parentheses substring is "()", which has length = 2.

Another example is ")()())", where the longest valid parentheses substring is "()()", which has length = 4.
*/

class Solution {
public:
    static int longestValidParentheses(string s) {
        // 1. 暴力算法，好听的名字：brute force
        // int max = 0;
        // for (int i = 0; i < s.length(); ++i)
        // {
        //     int len = 0, leftPCount = 0;
        //     for (int j = i; j < s.length(); ++j)
        //     {
        //         if (s[j] == '('){
        //             leftPCount++;
        //         }
        //         else if (leftPCount == 0)
        //             break;
        //         else{
        //             len += 2;
        //             leftPCount--;
        //             if (leftPCount == 0 && len > max)
        //             {
        //                 max = len;
        //             }
        //         }
        //     }
        // }
        // return max;

        // 2. Dynamic Programming
        // 我们维护一个一维dp数组，在位置k记录最长的、在位置k终止的字符串
        // 记住valid string的最后一个字母一定是')'
        // int *dp = new int[s.length()];
        // memset(dp, 0 , sizeof(int) * s.length());
        // int max = 0;
        // for (int i = 1; i < s.length(); ++i)
        // {
        //     if (s[i] == '(')continue;
        //     if (s[i-1] == '(')
        //     {
        //         // 如果xk-1 == '('，那么我们的')'必须和它配对，x1...xk-1()这样的字符串，只要加上dp[k-2]即可
        //         dp[i] = i < 2 ?  2 : dp[i-2] + 2;
        //     }
        //     else{
        //         // 如果不等于，那么我们可以减去dp[k-1]的长度，这段长度是一个完全匹配
        //         // 其中的左括号绝对不可以被匹配，不然就多了一个右括号
        //         // 而在这段长度前面，我们可以看第一个字符是否是左括号，是则匹配成功，否则匹配失败
        //         // 注意，对()(())这样的字符串，我们除了dp[k-1]+2以外，还要加上dp[i - dp[i-1] - 2]的长度
        //         // 也就是当前匹配的前面那个完全匹配
        //         dp[i] = s[i - dp[i-1] - 1] == '(' ? dp[i - dp[i-1] - 2] + dp[i-1] + 2 : 0;
        //         // dp[i - dp[i-1] - 2]可以直接用，因为这时候的i一定大于2
        //     }
        //     max = dp[i] > max ? dp[i] : max;
        //     cout<
        // }
        // cout<
        // return max;

        // 3. 栈方法
        // 栈里面维护的是没有匹配成功的［包括左括号和无法匹配的右括号］，这些位置是一个重新开始计算的位置
        // stack stc;
        // int maxans = 0;
        // stc.push(-1);
        // for (int i = 0; i < s.length(); ++i)
        // {
        //     if (s[i] == '(')
        //     {
        //         stc.push(i);
        //     }
        //     else
        //     {
        //         stc.pop();
        //         if (stc.empty())
        //         {
        //             stc.push(i);
        //         }
        //         else{
        //             maxans = max(maxans, i - stc.top());
        //         }
        //     }
        // }
        // return maxans;

        // 4. 无额外空间的方法
        // 左右各遍历一次，因为如果一个串不符合的话，要么是左括号多了，要么是右括号多了，把所有的情况都找出来就行了
        int left = 0, right = 0;
        int maxans = 0;
        for (int i = 0; i < s.length(); ++i)
        {
            if (s[i] == '(')
            {
                left++;
            }
            else{
                right++;
            }
            if (right > left)
            {
                right = left = 0;
            }
            else if (right == left)
            {
                maxans = max(maxans, right * 2);
            }
        }
        right = left = 0;
        for (int i = s.length() - 1; i >= 0; --i)
        {
            if (s[i] == '(')
            {
                left++;
            }
            else{
                right++;
            }
            if (right < left)
            {
                right = left = 0;
            }
            else if (right == left)
            {
                maxans = max(maxans, right * 2);
            }
        }
        return maxans;
    }
};