（LeetCode-Hot100）22. 括号生成

LeetCode 22.括号生成

问题简介

题目描述

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

📌 示例说明

示例 1：

复制代码

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]

示例 2：

复制代码

输入：n = 1
输出：["()"]

💡 解题思路

本题要求生成所有合法的括号组合。关键在于理解"合法"的定义：

任意前缀中左括号数量 ≥ 右括号数量；
总共左括号数量 = 右括号数量 = n。

方法一：回溯法（推荐）

这是最直观且高效的方法。

步骤如下：

使用递归构建字符串。
维护两个计数器：left（已使用的左括号数）、right（已使用的右括号数）。
在每一步：
- 如果 left < n，可以添加 '('；
- 如果 right < left，可以添加 ')'（保证不会出现非法右括号）。
当字符串长度为 2n 时，加入结果集。

✅ 该方法天然避免了无效组合，无需剪枝或后验检查。

方法二：暴力生成 + 有效性验证（不推荐）

生成所有长度为 2n 的由 '(' 和 ')' 构成的字符串（共 2 2 n 2^{2n} 22n 种）。
对每个字符串检查是否有效（使用栈或计数法）。
保留有效的结果。

❌ 时间复杂度过高，仅用于理解问题。

方法三：动态规划（进阶）

观察：任何合法括号序列可表示为 (A)B，其中 A 和 B 也是合法序列。

dp[i] 表示 i 对括号的所有合法组合。

递推关系：

复制代码

dp[i] = "(" + dp[j] + ")" + dp[i - 1 - j]  for j in [0, i-1]

💡 虽然可行，但实现较复杂，且空间开销大，不如回溯简洁。

💻 代码实现

java:Java 复制代码

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> res = new ArrayList<>();
        backtrack(res, new StringBuilder(), 0, 0, n);
        return res;
    }

    private void backtrack(List<String> res, StringBuilder cur, int left, int right, int n) {
        if (cur.length() == 2 * n) {
            res.add(cur.toString());
            return;
        }
        if (left < n) {
            cur.append('(');
            backtrack(res, cur, left + 1, right, n);
            cur.deleteCharAt(cur.length() - 1); // 回溯
        }
        if (right < left) {
            cur.append(')');
            backtrack(res, cur, left, right + 1, n);
            cur.deleteCharAt(cur.length() - 1); // 回溯
        }
    }
}

go:Go 复制代码

func generateParenthesis(n int) []string {
    res := []string{}
    var backtrack func(cur string, left, right int)
    backtrack = func(cur string, left, right int) {
        if len(cur) == 2*n {
            res = append(res, cur)
            return
        }
        if left < n {
            backtrack(cur+"(", left+1, right)
        }
        if right < left {
            backtrack(cur+")", left, right+1)
        }
    }
    backtrack("", 0, 0)
    return res
}

🧪 示例演示（n = 2）

递归过程示意（简化版）：

复制代码

""
├─ "("
│  ├─ "(("
│  │  └─ "(()"
│  │     └─ "(())" ✅
│  └─ "()"
│     └─ "()(" 
│        └─ "()()" ✅

最终输出：["(())", "()()"]

✅ 答案有效性证明

正确性：

每次添加 ')' 前确保 right < left，因此任意前缀中左括号 ≥ 右括号；
最终 left = right = n，总长度为 2n，满足完全匹配；
所有可能路径都被探索（因只要条件满足就递归），无遗漏。

完备性：

任一合法括号序列必可通过上述规则生成（数学归纳法可证）。

📊 复杂度分析

项目	分析
时间复杂度	O l e f t ( f r a c 4 n s q r t n r i g h t ) O\\left(\\frac{4^n}{\\sqrt{n}}\\right) Oleft(frac4nsqrtnright) ------ 第 n 个卡特兰数 C n = f r a c 1 n + 1 b i n o m 2 n n a p p r o x f r a c 4 n n 3 / 2 s q r t p i C_n = \\frac{1}{n+1}\\binom{2n}{n} \\approx \\frac{4^n}{n^{3/2}\\sqrt{\\pi}} Cn=frac1n+1binom2nnapproxfrac4nn3/2sqrtpi，即合法组合数
空间复杂度	O ( n ) O(n) O(n) ------ 递归栈深度最大为 2 n 2n 2n，忽略结果存储空间

💡 实际运行中，由于只生成有效序列，效率远高于暴力法。

📌 问题总结

核心思想：利用括号合法性的结构性质（左 ≥ 右），通过回溯剪枝。
关键技巧 ：用 left 和 right 计数器控制选择，避免无效路径。
适用场景：组合生成类问题，尤其是有约束条件的排列/组合。
延伸思考 ：此题是 卡特兰数 的经典应用之一，类似问题包括：二叉树结构计数、出栈序列等。

✅ 掌握回溯 + 剪枝思想，是解决此类问题的关键。

github地址: https://github.com/swf2020/LeetCode-Hot100-Solutions