天天AC系列(八):括號生成

1 題目

LeetCode第22題,根據一個整數生成全部的有效的括號組合,這個整數表示括號的對數.

2 暴力法

對於n對括號,總共2n個字符,每一個字符能夠爲左括號或右括號,因此總共2^(2n)中組合,暴力法就是枚舉各個組合,而後判斷它們是否爲有效的組合:

public void f(char c[],int pos,List<String> result)
{
    if(pos == c.length)
    {
        if(valid(c))
            result.add(Arrays.toString(c).replaceAll("(\\[)|(\\])| |,",""));
    }
    else
    {
        c[pos] = '(';
        f(c,pos+1,result);
        c[pos] = ')';
        f(c,pos+1,result);
    }
}

public boolean valid(char [] f)
{
    int len = 0;
    for(char c:f)
    {
        if(c == '(' )
        {
            if(++len > f.length/2)
                return false;
        }
        else if(len-- <=0)
            return false;
    }
    return len == 0;
}

首先加上左括號,進入下一輪遞歸,同時把加括號的位置加1,而後到達2n長度後,判斷是否有效,有效的話加入結果數組,而後回到上一層的遞歸,把當前位置的括號換成右括號,接着再次進入下一輪遞歸,同樣直到2n長度,繼續判斷是否有效,這樣不斷遞歸就會枚舉了全部的組合.

看來不太理想啊.

3 深搜

深搜的話是暴力的改進,暴力的話無論序列是什麼狀態都直接添加括號,而深搜的話,當序列有效時才添加括號. 添加左括號的條件:當前的左括號數量小於n. 添加右括號的條件:當前左括號的數量小於右括號的數量.

public void f(String c,int n,int l,int r,List<String> result)
{
    if(l == n && r == n)
        result.add(c);
    else
    {
        if(l < r)
            return ;
        if(l < n)
            f(c+"(",n,l+1,r,result);
        if(r < n)
            f(c+")",n,l,r+1,result);
    }
}

c爲上一次遞歸的結果,l,r分別表示左括號與右括號的數量,遞歸的結束條件是左右括號的數量均爲n,繼續遞歸的條件是左右括號的數量小於n.

4 動態規劃

設f(n)表示n對括號的全部有效序列,則有

具體來講:

f(3) = ( + f(0) + ) + f(2)
f(3) = ( + f(1) + ) + f(1)
f(3) = ( + f(2) + ) + f(0)

這三個都是三對括號的有效序列,所以f(3)最後的結果是這三個有效序列組成的數組.

由於f(n)不必定爲一個有效序列,所以返回值爲一個數組,剩下的只須要遍歷這個數組,把它們添加到最終結果數組中去:

public List<String> f(int n)
{
    List<String> s = new ArrayList<>();
    if(n == 0)
        s.add("");
    for(int i=0;i<n;++i)
    {
        List<String> l = f(i);
        List<String> r = f(n-i-1);
        for(String ll:l)
        {
            for(String rr:r)
            {
                s.add("("+ll+")"+rr);
            }
        }
    }
    return s;
}

若n爲0,添加一個空序列而後返回,若n不爲0,l表示i對括號的全部有效序列,r表示n-i-1對括號的全部有效序列,而後只須要遍歷這兩個序列,在兩邊加上左括號與右括號便可.

這個...好像沒有深搜快.

5 動規優化

上面的遞歸的動規沒有保存以前計算過的結果,好比計算n=3的時候,

f(3) = ( + f(0) + ) + f(2)
f(3) = ( + f(1) + ) + f(1)
f(3) = ( + f(2) + ) + f(0)

f(2):

f(2) = ( + f(1) + ) + f(0)
f(2) = ( + f(0) + ) + f(1)

f(1)

f(1) = ( + f(0) + ) + f(0)

只是計算f(3),計算了

f(2):2次
f(1):2+2*2=6次
f(0):2+2*2+6*2=18次

當n增大時,計算的重複度會變得更大,所以能夠考慮用一個數組存儲以前計算的結果,須要時直接取出來便可.

public List<String> generateParenthesis(int n) 
{
    List<List<String>> s = new ArrayList<>();
    s.add(Arrays.asList(""));
    s.add(Arrays.asList("()"));
    for(int n1 = 2;n1<=n;++n1)
    {
        List<String> t = new ArrayList<>();
        for(int i=0;i<n1;++i)
        {
            List<String> l = s.get(i);
            List<String> r = s.get(n1-i-1);
            for(String ll:l)
            {
                for(String rr:r)
                {
                    t.add("("+ll+")"+rr);
                }
            }
        }
        s.add(t);
    }
    return s.get(n);
}

能夠先看最後的return,由於s保存了0到n的全部結果,因此,直接get便可. 而後設置一個臨時的n1,表示當前要計算的n1對括號的序列,當n1增長時,表示已經完成了計算n1對括號的序列,t爲結果,添加到s中去.直到n1與n相等,計算完最後一個n1後,直接返回s的最後一個序列.

嗯,快了1ms,看來優化仍是有效果的.

6 源碼

github

碼雲