方法一：栈

遍历字符串，使用栈来存储左括号对应的下标

1、对于遇到的每个‘(’ ，将它的下标放入栈中

2、对于遇到的每个 ‘)’ ，先弹出栈顶元素表示匹配了当前右括号：

（1）、如果栈为空，说明当前的右括号为没有被匹配的右括号，将其下标放入栈中来更新我们之前提到的「最后一个没有被匹配的右括号的下标」

（2）、如果栈不为空，当前右括号的下标减去栈顶元素即为「以该右括号为结尾的最长有效括号的长度」

3、从前往后遍历字符串并更新答案即可。

需要注意的是，如果一开始栈为空，第一个字符为左括号的时候我们会将其放入栈中，这样就不满足提及的「最后一个没有被匹配的右括号的下标」，为了保持统一，我们在一开始的时候往栈中放入一个值为 -1 的元素。

时间复杂度：o(n)

空间复杂度：o(n)

class Solution {
  public:
    int longestValidParentheses(string s) {
        stack<int> res;
        // 子串长度，初始化为0
        int len = 0;
        // 记录上一次有效子串结束的位置，为了保持统一初始化为-1
        int start = -1;

        for (int i = 0; i < s.length(); i++) {
            if (s[i] == '(') {
                res.push(i);
            } else {
                if (res.empty()) {
                    start = i;
                } else {
                    res.pop();
                    if (res.empty()) {
                        len = max(len, i - start);
                    } else {
                        len = max(len, i - res.top());
                    }
                }
            }
        }
        return len;
    }
};

方法二：动态规划

创建大小为s.length()的数组dp，记录以s[i]为结尾的有效子串的长度。

有效子串一定是以右括号为结尾，所以遍历字符串，只有当前字符为右括号时才进行长度判断。

有两种情况：

1、s[i] = ')' 且 s[i-1] = '('，表示字符串形如 ‘......()’，则可推出：

dp[i] = dp[i-2] + 2

以进行这样的转移，是因为结束部分的 "()" 是一个有效子字符串，并且将之前有效子字符串的长度增加了 2

2、s[i] = ')' 且 s[i-1] = ')'，表示字符串形如 ‘......))’，则可推出：

如果s[i - dp[i-1] - 1] = '('，则

dp[i] = dp[i-1] + dp[i-dp[i-1]-2] + 2

考虑如果倒数第二个 ‘)’ 是一个有效子字符串的一部分（记作 subs），对于最后一个‘)’ ，如果它是一个更长子字符串的一部分，那么它一定有一个对应的 ‘(’ ，且它的位置在倒数第二个 ‘)’ 所在的有效子字符串的前面（也就是 subs的前面）。因此，如果子字符串 subs 的前面恰好是 ‘(’ ，那么我们就用 2 加上 subs 的长度（dp[i−1]）去更新 dp[i]。同时，也会把有效子串 “(subs)” 之前的有效子串的长度也加上，也就是再加上 dp[i−dp[i−1]−2]。

时间复杂度：o(n)

空间复杂度：o(n)

class Solution {
  public:
    int longestValidParentheses(string s) {
        vector<int> dp(s.length(), 0);
        int len = 0;
        for (int i = 1; i < s.length(); i++) {
            // 有效的子串一定是以右括号结尾
            if (s[i] == ')') {
                if (s[i - 1] == '(') {
                    dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;
                } else {
                    if (s[i - dp[i - 1] - 1] == '(' && i - dp[i - 1] > 0) {
                        dp[i] = dp[i - 1] +
                                ((i - dp[i - 1] >= 2) ? dp[i - dp[i - 1] - 2] : 0) + 2;
                    }
                }
            }
            len = max(len, dp[i]);
        }
        return len;
    }
};