數字 n 代表生成括號的對數，請你設計一個函數，用於能夠生成所有可能的並且 有效的 括號組合。
示例：
輸入：n = 3
輸出：[
"((()))",
"(()())",
"(())()",
"()(())",
"()()()"
]
方法一：深度優先遍歷
我們以 n = 2 爲例，畫樹形結構圖。方法是 “做減法”。
畫圖以後，可以分析出的結論：
當前左右括號都有大於 00 個可以使用的時候，才產生分支；
產生左分支的時候，只看當前是否還有左括號可以使用；
產生右分支的時候，還受到左分支的限制，右邊剩餘可以使用的括號數量一定得在嚴格大於左邊剩餘的數量的時候，纔可以產生分支；
在左邊和右邊剩餘的括號數都等於 00 的時候結算。
參考代碼 1：
JavaPython
import java.util.ArrayList;
import java.util.List;
public class Solution {
// 做減法
public List<String> generateParenthesis(int n) {
List<String> res = new ArrayList<>();
// 特判
if (n == 0) {
return res;
}
// 執行深度優先遍歷，搜索可能的結果
dfs("", n, n, res);
return res;
}
/**
* @param curStr 當前遞歸得到的結果
* @param left 左括號還有幾個可以使用
* @param right 右括號還有幾個可以使用
* @param res 結果集
*/
private void dfs(String curStr, int left, int right, List<String> res) {
// 因爲每一次嘗試，都使用新的字符串變量，所以無需回溯
// 在遞歸終止的時候，直接把它添加到結果集即可，注意與「力扣」第 46 題、第 39 題區分
if (left == 0 && right == 0) {
res.add(curStr);
return;
}
// 剪枝（如圖，左括號可以使用的個數嚴格大於右括號可以使用的個數，才剪枝，注意這個細節）
if (left > right) {
return;
}
if (left > 0) {
dfs(curStr + "(", left - 1, right, res);
}
if (right > 0) {
dfs(curStr + ")", left, right - 1, res);
}
}
}
我們運行 n = 2 的情況，得到結果 [(()), ()()] ，說明分析的結果是正確的。
如果我們不用減法，使用加法，即 left 表示“左括號還有幾個沒有用掉”，right 表示“右括號還有幾個沒有用掉”，可以畫出另一棵遞歸樹。
下面是參考代碼。
參考代碼 2：
JavaPython
import java.util.ArrayList;
import java.util.List;
public class Solution {
// 做加法
public List<String> generateParenthesis(int n) {
List<String> res = new ArrayList<>();
// 特判
if (n == 0) {
return res;
}
dfs("", 0, 0, n, res);
return res;
}
/**
* @param curStr 當前遞歸得到的結果
* @param left 左括號已經用了幾個
* @param right 右括號已經用了幾個
* @param n 左括號、右括號一共得用幾個
* @param res 結果集
*/
private void dfs(String curStr, int left, int right, int n, List<String> res) {
if (left == n && right == n) {
res.add(curStr);
return;
}
// 剪枝
if (left < right) {
return;
}
if (left < n) {
dfs(curStr + "(", left + 1, right, n, res);
}
if (right < n) {
dfs(curStr + ")", left, right + 1, n, res);
}
}
}
方法二：廣度優先遍歷
通過編寫廣度優先遍歷的代碼，讀者可以體會一下，爲什麼搜索幾乎都是用深度優先遍歷（回溯算法）。
廣度優先遍歷，得程序員自己編寫結點類，顯示使用隊列這個數據結構。深度優先遍歷的時候，就可以直接使用系統棧，在遞歸方法執行完成的時候，系統棧頂就把我們所需要的狀態信息直接彈出，而無須編寫結點類和顯示使用棧。
下面的代碼，讀者可以把 Queue 換成 Stack，提交以後，也可以得到 Accept。
讀者可以通過比較：
1、廣度優先遍歷；
2、自己使用棧編寫深度優先遍歷；
3、使用系統棧的深度優先遍歷（回溯算法）。
來理解 “回溯算法” 作爲一種 “搜索算法” 的合理性。
還是上面的題解配圖（1），使用廣度優先遍歷，結果集都在最後一層，即葉子結點處得到所有的結果集，編寫代碼如下。
感謝 @liu-ren-you 朋友幫我優化了代碼。
參考代碼 3：（前 2 個 Java 代碼寫法沒有本質不同，僅供參考。第 3 個 Java 代碼僅僅是把 Queue 換成了 Stack ，廣度優先遍歷就改成了深度優先遍歷。）
JavaJavaJava
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class Solution {
class Node {
/**
* 當前得到的字符串
*/
private String res;
/**
* 剩餘左括號數量
*/
private int left;
/**
* 剩餘右括號數量
*/
private int right;
public Node(String str, int left, int right) {
this.res = str;
this.left = left;
this.right = right;
}
}
public List<String> generateParenthesis(int n) {
List<String> res = new ArrayList<>();
if (n == 0) {
return res;
}
Queue<Node> queue = new LinkedList<>();
queue.offer(new Node("", n, n));
while (!queue.isEmpty()) {
Node curNode = queue.poll();
if (curNode.left == 0 && curNode.right == 0) {
res.add(curNode.res);
}
if (curNode.left > 0) {
queue.offer(new Node(curNode.res + "(", curNode.left - 1, curNode.right));
}
if (curNode.right > 0 && curNode.left < curNode.right) {
queue.offer(new Node(curNode.res + ")", curNode.left, curNode.right - 1));
}
}
return res;
}
}
方法三：動態規劃
參考了本題的 「官方題解」 中的 “閉合數方法” 和 「精選題解」，同樣的方法也可以用來完成 「力扣」第 95 題：“不同的二叉搜索樹 II”。
第 1 步：定義狀態 dp[i]：使用 i 對括號能夠生成的組合。
注意：每一個狀態都是列表的形式。
第 2 步：狀態轉移方程：
i 對括號的一個組合，在 i - 1 對括號的基礎上得到，這是思考 “狀態轉移方程” 的基礎；
i 對括號的一個組合，一定以左括號 "(" 開始，不一定以 ")" 結尾。爲此，我們可以枚舉新的右括號 ")" 可能所處的位置，得到所有的組合；
枚舉的方式就是枚舉左括號 "(" 和右括號 ")" 中間可能的合法的括號對數，而剩下的合法的括號對數在與第一個左括號 "(" 配對的右括號 ")" 的後面，這就用到了以前的狀態。
狀態轉移方程是：
dp[i] = "(" + dp[可能的括號對數] + ")" + dp[剩下的括號對數]
“可能的括號對數” 與 “剩下的括號對數” 之和得爲 i - 1（感謝 @xuyik 朋友糾正了我的錯誤），故 “可能的括號對數” j 可以從 0 開始，最多不能超過 i， 即 i - 1；
“剩下的括號對數” + j = i - 1，故 “剩下的括號對數” = i - j - 1。
整理得：
dp[i] = "(" + dp[j] + ")" + dp[i- j - 1] , j = 0, 1, ..., i - 1
第 3 步： 思考初始狀態和輸出：
初始狀態：因爲我們需要 0 對括號這種狀態，因此狀態數組 dp 從 0 開始，0 個括號當然就是 [""]。
輸出：dp[n] 。
這個方法暫且就叫它動態規劃，這麼用也是很神奇的，它有下面兩個特點：
1、自底向上：從小規模問題開始，逐漸得到大規模問題的解集；
2、無後效性：後面的結果的得到，不會影響到前面的結果。
參考代碼 4：
JavaPython
import java.util.ArrayList;
import java.util.List;
public class Solution {
// 把結果集保存在動態規劃的數組裏
public List<String> generateParenthesis(int n) {
if (n == 0) {
return new ArrayList<>();
}
// 這裏 dp 數組我們把它變成列表的樣子，方便調用而已
List<List<String>> dp = new ArrayList<>(n);
List<String> dp0 = new ArrayList<>();
dp0.add("");
dp.add(dp0);
for (int i = 1; i <= n; i++) {
List<String> cur = new ArrayList<>();
for (int j = 0; j < i; j++) {
List<String> str1 = dp.get(j);
List<String> str2 = dp.get(i - 1 - j);
for (String s1 : str1) {
for (String s2 : str2) {
// 枚舉右括號的位置
cur.add("(" + s1 + ")" + s2);
}
}
}
dp.add(cur);
}
return dp.get(n);
}
}