《LeetBook》LeetCode題解(22): Generate Parentheses[M]

我現在在做一個叫《leetbook》的免費開源書項目，力求提供最易懂的中文思路，目前把解題思路都同步更新到gitbook上了，需要的同學可以去看看
書的地址：https://hk029.gitbooks.io/leetbook/

問題

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

For example, given n = 3, a solution set is:

”((()))”, “(()())”, “(())()”, “()(())”, “()()()”

思路1——DP

設：P[i]表示當n=i的時候括號組合串。
觀察規律：我們知道，要形成一個括號的組合，肯定不是憑空產生的，產生一個P[3]的組合，那肯定是把”(“和”)”分別插在P[2]中間的。

我們假設產生P[3]組合的時候，之前的組合都是正確的，那麼通過插入”(“，”)”肯定會把P[2]分成兩個部分（括號內一個，括號外一個）

看似好像有很多插入的方法，但是，其實仔細想想，反正”(“得增加一個，由於括號組合的第一一定是”(“，爲什麼不把新增的”(“放在開頭呢？這樣我們就只用考慮”)”了

會怎麼把P[2]切割就好了，我們知道P[2]的組合有
P[0]+P[2]，P[1]+P[1]，P[2]+P[0]，

通過寫出前幾個可以觀察到下面的規律
P[0]= [“”]

P[1] = [()] = “(“+P[0]+”)”+P[0]

P[2] = [()(),(())] = “(“+P[0]+”)”+P[1] , “(“+P[1]+”)” +P[0]

P[3] = [()()(),()(()),(())(),(()()),((()))] =
“(“+P[0]+”)”+P[2] , “(“+P[1]+”)”+P[1], “(“+P[2]+”)” +P[0]

我們可以知道組合方式：

• P[i] = “(“+P[i-j-1]+”)”+P[j] (j∈[0,n−1] )

public class Solution {
    public List<String> generateParenthesis(int n) {
        List<List<String>> result = new ArrayList<List<String>>();
        //初始化P[0] = ""
        result.add((List<String>)Arrays.asList(new String []{""}));       
        for(int i=1;i <= n;i++)
        {
            result.add(new ArrayList<>());
            for(int j = 0; j < i;j++)
            {
                //獲取P[k]
                for (String s1 : result.get(j)) {
                    //獲取P[i-j-1]
                    for(String s2 : result.get(i-j-1))
                    {
                         result.get(i).add("(" + s1 + ")" + s2);
                    }
                }
            }
        }
        return result.get(n);
    }
}

思路2：回溯

假設我能枚舉所有的情況，我們考慮合理的括號組合是什麼樣的：

• 左括號數==右括號數
• 左括號一定要先於右括號

所以我們可以用一個大數組來表示字符串，2個指針left，right來表示左右括號，我們遞歸遍歷所有情況，把滿足條件的情況加入list就行了。

public class Solution {
    public List<String> generateParenthesis(int n) {
        LinkedList<String> result = new LinkedList<String>();
        if(n== 0)   return result;
        backtracing(result,0,0,"",n);
        return result;
    }
    void backtracing(LinkedList<String> result, int left, int right, String par, int max)
    {
        if(par.length() == 2*max)
        {
            result.add(par);
            return;
        }
        if(left < max)
            backtracing(result,left+1,right,par+'(',max);
        if(right < left)
            backtracing(result,left,right+1,par+')',max);    
    }

}