1. 题目解析与核心思路
最长有效括号问题是一个经典的字符串处理题目，要求我们找到给定字符串中最长的连续有效括号子串的长度。有效括号的定义是每个左括号都能找到对应的右括号闭合，并且这些括号是连续排列的。
1.1 问题难点分析
这个问题的难点主要体现在以下几个方面：
-
连续性要求：我们需要找到的是连续的有效括号子串，而不是分散的有效括号对。例如在字符串"()(()"中，虽然有两个有效的"()"对，但它们不是连续的，所以最长有效长度是2而不是4。
-
嵌套结构处理：有效括号可能包含多层嵌套，如"(()())"这样的结构，简单的计数器无法处理这种嵌套关系。
-
边界条件：需要考虑空字符串、全左括号、全右括号等各种边界情况。
1.2 解法概览
针对这个问题，我们主要讨论三种解法：
-
动态规划解法：通过定义状态数组dp[i]表示以i结尾的最长有效括号长度，利用之前的状态推导当前状态。
-
栈解法：利用栈结构来匹配括号对，同时记录索引来计算有效长度。
-
正反向计数法：通过两次遍历（从左到右和从右到左）统计括号数量，找到有效区间。
2. 动态规划解法详解
动态规划是解决这类字符串匹配问题的有效方法，下面我们详细解析这种解法的实现思路。
2.1 状态定义
我们定义dp[i]表示以第i个字符结尾的最长有效括号子串的长度。根据有效括号的定义，只有以右括号')'结尾的子串才可能是有效的，所以对于左括号'('，dp[i]始终为0。
2.2 状态转移方程
对于当前字符s[i]为')'的情况，我们需要考虑两种子情况：
2.2.1 情况一：前一个字符是'('
即形如"...()"的结构。这种情况下，当前这对括号可以直接形成一个有效对，因此：
code复制dp[i] = dp[i-2] + 2
这里dp[i-2]表示这对括号之前可能存在的有效长度。
2.2.2 情况二：前一个字符是')'
即形如"...))"的结构。这种情况下，我们需要检查是否能形成一个更大的有效块。具体步骤：
- 计算前一个有效块的起始位置：
beforePrevIndex = i - dp[i-1] - 1 - 如果这个位置的字符是'('，则说明可以形成更大的有效块：
code复制这里包含三部分：内部块长度、新增的外层括号长度、以及前面可能连接的其他有效块长度。dp[i] = dp[i-1] + 2 + dp[beforePrevIndex - 1]
2.3 代码实现与注释
java复制class Solution {
public int longestValidParentheses(String s) {
if (s == null || s.length() == 0) return 0;
int n = s.length();
int[] dp = new int[n];
int max = 0;
for (int i = 1; i < n; i++) {
if (s.charAt(i) == ')') {
// 情况1：直接匹配"()"
if (s.charAt(i - 1) == '(') {
dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;
}
// 情况2：处理嵌套结构"))"
else if (i - dp[i - 1] - 1 >= 0 && s.charAt(i - dp[i - 1] - 1) == '(') {
dp[i] = dp[i - 1] + 2;
// 检查前面是否还有连接的有效块
if (i - dp[i - 1] - 2 >= 0) {
dp[i] += dp[i - dp[i - 1] - 2];
}
}
max = Math.max(max, dp[i]);
}
}
return max;
}
}
2.4 复杂度分析
- 时间复杂度：O(n)，只需要一次遍历字符串。
- 空间复杂度：O(n)，用于存储dp数组。
3. 栈解法详解
栈是处理括号匹配问题的经典数据结构，下面我们详细分析如何使用栈来解决这个问题。
3.1 基本思路
栈解法的核心思想是：
- 使用栈来保存未匹配的左括号的索引
- 初始化时压入一个哨兵值-1，作为边界标记
- 遇到左括号压栈，遇到右括号弹栈
- 通过当前索引和栈顶元素的差值计算有效长度
3.2 关键步骤解析
3.2.1 初始化
java复制Deque<Integer> stack = new LinkedList<>();
stack.push(-1); // 初始哨兵
这个哨兵值-1的作用是作为计算长度的基准点。例如当第一对就是"()"时，有效长度为1 - (-1) = 2。
3.2.2 处理右括号
当遇到右括号时：
- 首先弹栈（可能是匹配的左括号或哨兵）
- 如果栈为空，说明当前右括号没有匹配，将其索引压栈作为新的基准
- 如果栈不为空，计算当前有效长度并更新最大值
3.3 完整代码实现
java复制class Solution {
public int longestValidParentheses(String s) {
int max = 0;
Deque<Integer> stack = new LinkedList<>();
stack.push(-1); // 初始哨兵
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == '(') {
stack.push(i);
} else {
stack.pop();
if (stack.isEmpty()) {
stack.push(i); // 更新基准
} else {
max = Math.max(max, i - stack.peek());
}
}
}
return max;
}
}
3.4 复杂度分析
- 时间复杂度：O(n)，每个字符最多入栈出栈一次。
- 空间复杂度：O(n)，最坏情况下需要存储所有左括号索引。
4. 正反向计数法详解
这种方法通过两次遍历统计括号数量，无需额外空间，是最优的空间复杂度解法。
4.1 基本思路
-
从左到右遍历：
- 统计左右括号数量
- 当左右相等时，更新最大长度
- 当右括号多于左括号时，重置计数器（处理右括号多余的情况）
-
从右到左遍历：
- 同样统计括号数量
- 当左右相等时，更新最大长度
- 当左括号多于右括号时，重置计数器（处理左括号多余的情况）
4.2 关键点说明
- 为什么要两次遍历：单次遍历只能处理一种括号多余的情况，例如从左到右只能处理右括号多余，无法处理像"(()"这样的左括号多余情况。
- 计数规则：每次遍历时，相等条件
left == right保证了当前区间是有效的，因为每个左括号都有对应的右括号闭合。
4.3 完整代码实现
java复制class Solution {
public int longestValidParentheses(String s) {
int left = 0, right = 0, max = 0;
// 从左到右遍历
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == '(') {
left++;
} else {
right++;
}
if (left == right) {
max = Math.max(max, 2 * right);
} else if (right > left) {
left = right = 0;
}
}
left = right = 0;
// 从右到左遍历
for (int i = s.length() - 1; i >= 0; i--) {
if (s.charAt(i) == '(') {
left++;
} else {
right++;
}
if (left == right) {
max = Math.max(max, 2 * left);
} else if (left > right) {
left = right = 0;
}
}
return max;
}
}
4.4 复杂度分析
- 时间复杂度：O(n)，两次遍历字符串。
- 空间复杂度：O(1)，只使用了常数个变量。
5. 解法对比与选择建议
5.1 三种解法对比
| 解法 | 时间复杂度 | 空间复杂度 | 适用场景 | 实现难度 |
|---|---|---|---|---|
| 动态规划 | O(n) | O(n) | 通用解法，适合大多数情况 | 中等 |
| 栈 | O(n) | O(n) | 需要理解栈的匹配机制 | 中等 |
| 正反向计数 | O(n) | O(1) | 空间受限场景 | 较难 |
5.2 选择建议
- 面试场景：推荐使用动态规划或栈解法，因为它们思路清晰，易于解释。
- 竞赛场景：如果空间限制严格，选择正反向计数法。
- 学习建议：建议先掌握动态规划解法，理解状态转移思想后，再学习其他解法。
6. 常见问题与调试技巧
6.1 常见错误
- 边界条件处理不当：忘记处理空字符串或全左/右括号的情况。
- 索引越界：在动态规划解法中，访问dp[i-2]等位置时未检查索引有效性。
- 栈空判断错误：在栈解法中，弹栈后未正确处理栈为空的情况。
6.2 调试技巧
- 打印中间状态：对于动态规划解法，可以打印dp数组观察状态变化。
- 小样例测试：使用简单测试用例如"()", ")(", "(()"等验证基本逻辑。
- 单步调试：对于栈解法，可以记录每次操作后的栈状态。
6.3 测试用例建议
java复制// 基础测试用例
assertEquals(2, solution.longestValidParentheses("(()"));
assertEquals(4, solution.longestValidParentheses(")()())"));
assertEquals(0, solution.longestValidParentheses(""));
assertEquals(0, solution.longestValidParentheses("((("));
// 复杂测试用例
assertEquals(6, solution.longestValidParentheses("(()())"));
assertEquals(2, solution.longestValidParentheses("()(()"));
assertEquals(4, solution.longestValidParentheses("()()"));
7. 算法优化与变种思考
7.1 可能的优化方向
- 空间优化：动态规划解法中，可以观察到dp[i]只依赖于前面有限的几个状态，可以优化为O(1)空间。
- 并行计算：正反向计数法的两次遍历可以尝试并行化处理。
7.2 相关问题变种
- 验证括号有效性：只需判断整个字符串是否有效，不需要找最长子串。
- 生成所有有效括号组合：给定n，生成所有可能的n对有效括号组合。
- 多种括号类型：处理包含{}, [], ()等多种括号的情况。
在实际编码练习中，我发现动态规划解法虽然需要额外的空间，但其思路最为直观，适合作为这类问题的通用解法模板。特别是在处理复杂的字符串匹配问题时，定义合适的状态和转移方程往往能提供清晰的解决路径。