Leetcode1-100: 22. Generate Parentheses

问题描述

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:

[
  "((()))",
  "(()())",
  "(())()",
  "()(())",
  "()()()"
]

题目要求是输入一个数字n，给出所有符合要求的n对括号的组合串的集合。

解题思路

1. Brute force 生成所有满足要求的字符串，然后判断是否需要加入结果集中
2. 递归法，每次用一个值来加入试验串中然后得到所有可能的结果集。判断如果左括号小于n则可以继续加入左括号，右括号小于左括号就可以继续加入右括号。
3. 拆分法，考虑一个长度为n的合法串的构成，当n大于等于1的时候，可以拆分成两个部分，即：

'('+左半部分+')' +右部分

只需要保证左部分和右部分的长度和为2n-2即可确保长度符合要求。所以只需要迭代式子中右括号的位置即可遍历所有可能性。具体实现见代码

代码实现

implement 1 Brute force

    public List<String> generateParenthesis(int n) {
        List<String> res = new ArrayList();
        generateAllStrings(new char[n * 2], 0, res);
        return res;
    }
    
    public void generateAllStrings(char[] str, int position, List<String> res) {
        if(position == str.length) {
            //System.out.println(1);
            if(isValid(str)) 
                res.add(String.valueOf(str));
        }
            
        else {
        	//当前位置的可能性有两种， '(' 和 ')' 分别考虑
            str[position] = '(';
            generateAllStrings(str, position + 1, res);
            str[position] = ')';
            generateAllStrings(str, position + 1, res);
        }
    }
    
    //线性算法判断是否是一个合法字符串，计算左括号和右括号的数量，在任意位置如果右括号多于左括号那么就是不合法的串
    public boolean isValid(char[] str) {
        int start = 0, end = 0;
        for(int i = 0; i < str.length; i++) {
            if(str[i] == '(')
                start++;
            if(str[i] == ')')
                end++;
            if(start < end) 
                return false;
        }
        return (start == end);
    }

implement 2 回溯法

    public List<String> generateParenthesis(int n) {
        List<String> res = new ArrayList();
        backtrack(res, "", 0, 0, n);
        return res;  
    }
    
    public void backtrack(List<String> ans, String cur, int open, int close, int max) {
        if(cur.length() == 2 * max) {
            ans.add(cur);
            return;
        }
        if(open < max) //如果左括号没有到数量，可以继续添加左括号
            backtrack(ans, cur+"(", open+1, close, max);
        if(close < open) //如果左括号大于右括号， 可以继续添加右括号
            backtrack(ans, cur+")", open, close+1, max);
    }

本来这个实现想了很久合理性，觉得不大确定这个顺序能否做到遍历所有可行答案。后来发现想多了，递归的本质实际就可以确定所有结果。而且代码里面规定的只是添加左括号和右括号的场景，所以递归会自动探索所有可能的。如果想不明白的话可以用n=3或者n=2的例子自己走一遍试试会清楚很多。

implement 3 拆分法

public List<String> generateParenthesis(int n) {
    if(n == 0) return new ArrayList(){
        {
            add("");
        }
    };
    List <String> res = new ArrayList();
    for(int i = 0; i < n; i++) {
        for(String left: generateParenthesis(i))
            for(String right: generateParenthesis(n - 1 - i)) {
            	//分析中提到的实现式子
                res.add("("+left+")"+right);
            }
    }
    return res;
}

复杂度分析

impl. 1：实现的时间复杂度是O(2²ⁿn)，空间复杂度是O(2²ⁿn)，一共有2²ⁿ种可能性，每种可能性都是n来判断是否合法
impl. 2：实现的时间复杂度是 O($$\frac{1}{n+1}\left(\genfrac{}{}{0ex}{}{n}{2n}\right)$$) 空间复杂度也是O($$\frac{1}{n+1}\left(\genfrac{}{}{0ex}{}{n}{2n}\right)$$)，详情见卡塔兰数的分析，讲的还是很有意思的。
impl. 3：实现的时间复杂度和空间复杂度都跟实现2相同，因为两种算法都是直接给出所有合法的串。

分析

这题还是比较有意思的，尤其是复杂度的算法感觉像是回到了高中一样的。
之前生病了有点头疼，今天补两天的数量吧。