【力扣100题】50.最长有效括号

题目描述

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

左右括号匹配，即每个左括号都有对应的右括号将其闭合的字符串是格式正确的，例如 "(()())"。

示例：

• 输入：s = "(()" → 输出：2（最长有效括号子串是 "()")
• 输入：s = ")()())" → 输出：4（最长有效括号子串是 "()()")
• 输入：s = "" → 输出：0

---

解题思路总览

方法	思路	时间复杂度	空间复杂度
动态规划	dp[i] 表示以第 i 个字符结尾的最长有效括号长度	O(n)	O(n)
栈	栈中存索引，遇到 ) 时弹出并计算长度	O(n)	O(n)
双指针	两遍扫描，分别从左到右和从右到左处理不匹配的情况	O(n)	O(1)

本题采用动态规划方法。

---

完整代码

class Solution {
public:
    int longestValidParentheses(string s) {
        int maxLen = 0, n = s.size();
        vector<int> dp(n, 0);
        for (int i = 1; i < n; i++) {
            if (s[i] == ')') {
                if (s[i - 1] == '(') {
                    dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;
                } else if (i - dp[i - 1] > 0 && s[i - dp[i - 1] - 1] == '(') {
                    dp[i] = dp[i - 1] + ((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2;
                }
                maxLen = max(maxLen, dp[i]);
            }
        }
        return maxLen;
    }
};

---

算法流程图

输入: s = ")()())"

初始化:
  n = 6
  dp[0...5] = 0
  maxLen = 0

i = 1, s[1] = '(':
  s[1] == ')'? 否，跳过
  maxLen = 0

i = 2, s[2] = ')':
  s[2] == ')'? 是
  s[1] == '('? 是！
    dp[2] = dp[0] + 2 = 0 + 2 = 2
  maxLen = max(0, 2) = 2

i = 3, s[3] = '(':
  s[3] == ')'? 否，跳过
  maxLen = 2

i = 4, s[4] = ')':
  s[4] == ')'? 是
  s[3] == '('? 是！
    dp[4] = dp[2] + 2 = 2 + 2 = 4
  maxLen = max(2, 4) = 4

i = 5, s[5] = ')':
  s[5] == ')'? 是
  s[4] == '('? 否，进入 else if
    i - dp[4] = 5 - 4 = 1 > 0
    s[1] = '('? 是！
    dp[5] = dp[4] + dp[0] + 2 = 4 + 0 + 2 = 6
  maxLen = max(4, 6) = 6

最终 maxLen = 6
输出: 6

---

逐行解析

int maxLen = 0, n = s.size();

含义： maxLen 记录全局最长有效括号长度，n 记录字符串长度。

vector<int> dp(n, 0);

含义： dp[i] 表示以第 i 个字符结尾的最长有效括号子串长度。初始化为 0。

for (int i = 1; i < n; i++)

含义： 从索引 1 开始遍历（因为 dp0 只能是 0，不需要计算）。

if (s[i] == ')')

含义： 只有当当前字符是 ) 时才可能形成有效括号。

if (s[i - 1] == '(')

含义： 情况一："..." 形式的最近匹配。例如 "()" 或 "(...)()"

dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;

含义： 如果是 "()" 形式，长度为 2 加上 dpi-2（之前已匹配的长度）。需要判断 i-2 是否 >= 0。

else if (i - dp[i - 1] > 0 && s[i - dp[i - 1] - 1] == '(')

含义： 情况二：类似 "(...])" 的形式，其中 ... 已经是有效括号段。例如 "(())" 中 s3=')' 时，i-dpi-1=3-2=1，s0='('，形成匹配。

dp[i] = dp[i - 1] + ((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2;

含义：

• dp[i - 1]：之前已经匹配的有效括号长度
• ((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0)：加上再之前的有效括号长度
• + 2：加上当前匹配的 "()"

maxLen = max(maxLen, dp[i]);

含义： 更新全局最长长度。

---

状态转移图解

情况一："()" 形式
        i-1   i
        '('   ')'
  dp[i] = dp[i-2] + 2

情况二："(...])" 形式
             i-1      i
        "... ( ... ) )"
                 ^dp[i-1]
        ^
        i - dp[i-1] - 1 (与 i 配对的 '(' 的位置)
  dp[i] = dp[i-1] + dp[i - dp[i-1] - 2] + 2

---

复杂度分析

复杂度	值	说明
时间复杂度	O(n)	只需遍历一次字符串
空间复杂度	O(n)	dp 数组大小为 n

---

面试追问 FAQ

问题	答案
为什么从 i = 1 开始而不是 i = 0？	因为 dp0 一定是 0（空字符串无法形成有效括号），从 1 开始可以减少边界判断
dp[i] 为什么要定义为「以第 i 个字符结尾」？	这样可以利用 dpi-1 的值，实现 O(1) 转移。如果是「前 i 个字符中最长」，就无法利用之前的结果
栈方法是怎么工作的？	栈中存左括号的索引，遇到右括号时弹出。如果弹出后栈非空，当前长度 = i - 栈顶索引；如果栈空，当前长度 = i + 1
双指针方法的原理？	从左到右扫描时，遇到不匹配的 ) 就重置；从右到左扫描时，遇到不匹配的 ( 就重置。两遍扫描可以覆盖所有情况
如何输出具体的最长有效括号子串？	在计算 dpi 时记录 maxLen 对应的位置，然后从该位置向前截取 maxLen 长度的子串
进阶：如何 O(1) 空间？	使用双指针方法：分别从左到右和从右到左扫描，处理不匹配的括号情况

---

相关题目

题号	题目	难度	核心思路
32	最长有效括号	困难	动态规划/栈/双指针
20	有效的括号	简单	栈
22	括号生成	中等	DFS/回溯
301	删除无效的括号	困难	BFS/DFS

---

总结

要点	内容
核心思想	动态规划：以每个 ) 结尾计算最长有效括号长度
状态定义	dp[i] = 以第 i 个字符结尾的最长有效括号长度
状态转移	情况一："()", dpi = dpi-2 + 2
状态转移	情况二："(...])", dpi = dpi-1 + dpi-dp\[i-1-2] + 2
边界处理	需要判断索引是否越界
结果	返回 maxLen

---