32. Longest Valid Parentheses

▶ 在一串 '(' 和 ')' 组成的字符串中寻找最长的匹配的子串，如 ())，(())，()()，()(()) 等都算合法。

● 代码，暴力搜索，超时。使用两个变量枚举原字符串的 O(n²) 个子串，每个子串用 O(n) 的时间去验证是否匹配，时间复杂度 O(n³)，以下为稍微改进的版本，没有本质变化。

class Solution
{
public:
    bool check(string & ss, int start, int end)
    {
        int i, count;
        for (i = start, count = 0; i <= end; i++)
        {
            ss[i] == '(' ? count++ : count--;
            if (count < 0)
                return false;
        }
        return (count == 0);
    }
    int longestValidParentheses(string s)
    {
        if (s.size() <= 1)
            return 0;

        int i, j, maxLength;
        for (i = 1, maxLength = 0; i < s.size(); i++)
        {
            if (s[i] == '(')
                continue;
            for (j = 0; j < i - maxLength; j++)// 每找到一个 ') '就从 s 开头开始寻找最长的合法串，
            {
                if (check(s, j, i) && i - j + 1 > maxLength)// 找到的合法串比之前的更长，则更新 maxLength
                    maxLength = i - j + 1;
            }
        }
        return maxLength;
    }
};

● 代码，愚蠢的动态规划，326 ms 。想到了用动态规划但是没有用对方法，使用数组 maxLength 来保存原字符串各前缀的最大匹配长度，还需要维护另外两个数组 maxStart 和 maxAtEnd（两者等价，不同情况下可使表达式稍微简化）来记录相关信息，且三个数组间相互关联不明显。

class Solution
{
public:
    bool check(string & ss, int start, int end)// 检查 s 中下标从 start 到 end（两边都取得到）是否匹配
    {
        if (end < start || !((end - start) % 2))// 起点在终点右边，或者包含奇数个字符，肯定不匹配
            return false;        
        int i, count; 
        for (i = start, count = 0; i <= end; i++)
        {
            ss[i] == '(' ? count++ : count--;
            if (count < 0)
                return false;
        }
        return (count == 0); 
    }
    int longestValidParentheses(string s)
    {
        if (s.size() <= 1)
            return 0;
        int i, j, temp;
        vector<int> maxLength(s.size(), 0);     // maxLength[i] 记录 s[0] ~ s[i] 最大匹配长度 
        vector<int> maxStart(s.size(), 0);      // maxStart[i] 记录 s[0] ~ s[i] 最大匹配长度的起点 
        vector<bool> maxAtEnd(s.size(), false); // maxAtEnd[i] = (maxStart[i] + maxLength[i] -1 == i)，即最大匹配长度是否位于末尾
        
        for (i = 1; i < s.size(); i++)// 填表，每次循环在末尾添加一个字符，研究匹配情况
        {
            maxLength[i] = maxLength[i - 1];
            maxStart[i] = maxStart[i - 1];
            if (s[i] == '(')
                continue;
            if (maxAtEnd[i - 1])// 长为 i 的前缀（下标为 i - 1）中最长匹配位于末尾
            {
                if (maxStart[i - 1] > 0 && s[maxStart[i - 1] - 1] == '(')// 检查该匹配前一个字符是否为 '('，否则不能成为更长的匹配
                {
                    for (j = maxStart[i - 1] - 2 - maxLength[maxStart[i - 1] - 2];
                        j < maxStart[i - 1] - 2 && !check(s, j, maxStart[i - 1] - 2); j++);
                        // 以上面找到的 '(' 左侧的字符为起点， 继续往前寻找匹配。
                        // 不一定是该范围内的最长匹配，但长度不超过该范围的最大匹配长度 maxLength[maxStart[i - 1] - 2]
                    if (j < maxStart[i - 1] - 2)// 找到了新的最长匹配，更新数据
                    {
                        maxLength[i] = i - j + 1;
                        maxStart[i] = j;                        
                    }
                    else// 没有找到新的最长匹配，仅在原来的基础上扩展一对括号
                    {
                        maxLength[i] += 2;
                        maxStart[i] -= 1;
                    }
                    maxAtEnd[i] = true;
                }
            }
            else if (check(s, temp = maxStart[i - 1] + maxLength[i - 1], i))// 恰能在原匹配的后面接上一个匹配
            {
                maxLength[i] += i - temp + 1;
                maxAtEnd[i] = true;
            }
            else    // 完全不能与原匹配产生联系，在后半段逐个查找
            {
                for (j = temp + 1; j < i && i - j + 1 >= maxLength[i]; j++)
                {
                    if (check(s, j, i))
                    {
                        maxLength[i] = i - j + 1;
                        maxStart[i] = j;
                        maxAtEnd[i] = true;
                    }
                }
            }
        }
        return maxLength[s.size() - 1];
    }
};

● 代码，正确的动态规划，10 ms 。数组 dp[ i ] 记录的是 “以 s[ i ] 为结尾的子串的最大匹配长度”，可以根据 s[ i - 1 ] 的值简单的分为两种情况。

class Solution
{
public:
    int longestValidParentheses(string s)
    {
        int output = 0;
        vector<int> dp(s.size());
        for (int i = 1; i < s.length(); i++)
        {
            if (s[i] == ')')
            {
                if (s[i - 1] == '(')                        // "...(...√...)()" 型，使用 dp[i-2] 来计算 
                    (i >= 2) ? (dp[i] = dp[i - 2] + 2) : (dp[i] = 2);
                else if (i - dp[i - 1] > 0 && s[i - dp[i - 1] - 1] == '(')//  "(...√...)((...√...))" 型，要计算 dp[i-1] 以及更前面的那个
                    (i - dp[i - 1] >= 2) ? (dp[i] = dp[i - 1] + dp[i - dp[i - 1] - 2] + 2) : (dp[i] = dp[i - 1] + 2); 
                output = (dp[i] > output) ? dp[i] : output;
            }
        }
        return output;
    }
};

● 代码，栈法，13 ms 。

class Solution
{
public:
    int longestValidParentheses(string s)
    {
        int output = 0;
        stack<int> st;
        st.push(-1);
        for (int i = 0; i < s.length(); i++)
        {
            if (s[i] == '(')
                st.push(i);
            else // 遇 ')' 出栈并计算
            {
                st.pop();
                if (st.empty())
                    st.push(i);
                else
                    output = (i - st.top() > output) ? i - st.top() : output;
            }
        }
        return output;
    }
};

● 代码，神奇的左右扫描法，13 ms 。两个方向扫描数组，计算最大匹配长度作为输出。

class Solution
{
public:
    int longestValidParentheses(string s)
    {
        int left = 0, right = 0, maxLength = 0;
        for (int i = 0; i < s.length(); i++)        // 从左往右扫描，相等时计算最大匹配长度，')' 不少于 '(' 时计数归零
        {
            (s[i] == '(') ? left++ : right++;
            if (left == right)
                maxLength = (2 * right > maxLength) ? 2 * right : maxLength; 
            else if (right >= left)
                left = right = 0;
        }
        left = right = 0;
        for (int i = s.length() - 1; i >= 0; i--)   // 从右往左扫描，相等时计算最大匹配长度，'(' 不少于 ')' 时计数归零
        {
            (s[i] == '(') ? left++ : right++;
            if (left == right)
                maxLength = (2 * left > maxLength) ? 2 * left : maxLength;
            else if (left >= right)
                left = right = 0;
        }
        return maxLength;
    }
};