2020-12-22

力扣刷题

题目

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

示例：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/generate-parentheses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

java解答

1.暴力求解：首先生成所有 2^2n个 ‘(’ 和 ‘)’ 字符构成的序列，然后判断每一个序列是否有效。

class Solution {
     public boolean vaild(char[] current){
        int balance=0;
        for(char c:current){
            if(c=='('){
                ++balance;
            }else{
                --balance;
            }
            if(balance<0){
                return false;
            }
        }
        return balance==0;
    }
    public void generateAll(char[] current,int pos,List<String> result){
        if(pos==current.length){
            if(vaild(current)){
                result.add(new String(current));
            }
        }else{
                current[pos]='(';
                generateAll(current,pos+1,result);
                current[pos]=')';
                generateAll(current,pos+1,result);
            }
    }
    public List<String> generateParenthesis(int n) {
        List<String> combinations=new ArrayList<String>();
        generateAll(new char[2*n],0,combinations);
        return combinations;
    }
}

2.暴力求解的优化，使用回溯法生成序列。可以只在序列仍然保持有效时才添加 ‘(’ or ‘)’，而不是像 方法一 那样每次添加。可以通过跟踪到目前为止放置的左括号和右括号的数目来做到这一点，如果左括号数量不大于 n，可以放一个左括号。如果右括号数量小于左括号的数量，可以放一个右括号。

class Solution {
     public void backtrack(List<String> ans,StringBuilder cur, int open,int close,int max){
        if(cur.length()==max*2){
            ans.add(cur.toString());
            return;
        }
        if(open<max){
            cur.append('(');
            backtrack(ans,cur,open+1,close,max);
            cur.deleteCharAt(cur.length()-1);
        }
        if(open>close){
            cur.append(')');
            backtrack(ans,cur,open,close+1,max);
            cur.deleteCharAt(cur.length()-1);
        }
    }
    public List<String> generateParenthesis(int n) {
        List<String> ans=new ArrayList<String>();
        backtrack(ans,new StringBuilder(),0,0,n);
        return ans;
    }
}

3.按括号序列的长度递归
任何一个括号序列都一定是由 ( 开头，并且第一个 ( 一定有一个唯一与之对应的 )。这样一来，每一个括号序列可以用 (a)b 来表示，其中 a 与 b 分别是一个合法的括号序列（可以为空）。

那么，要生成所有长度为 2 * n 的括号序列，我们定义一个函数 generate(n) 来返回所有可能的括号序列。那么在函数 generate(n) 的过程中：

我们需要枚举与第一个 ( 对应的 ) 的位置 2 * i + 1；
递归调用 generate(i) 即可计算 a 的所有可能性；
递归调用 generate(n - i - 1) 即可计算 b 的所有可能性；
遍历 a 与 b 的所有可能性并拼接，即可得到所有长度为 2 * n 的括号序列。
为了节省计算时间，我们在每次 generate(i) 函数返回之前，把返回值存储起来，下次再调用 generate(i) 时可以直接返回，不需要再递归计算。

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/generate-parentheses/solution/gua-hao-sheng-cheng-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
     ArrayList[] cache = new ArrayList[100];

    public List<String> generate(int n) {
        if (cache[n] != null) {
            return cache[n];
        }
        ArrayList<String> ans = new ArrayList<String>();
        if (n == 0) {
            ans.add("");
        } else {
            for (int c = 0; c < n; ++c) {
                for (String left: generate(c)) {
                    for (String right: generate(n - 1 - c)) {
                        ans.add("(" + left + ")" + right);
                    }
                }
            }
        }
        cache[n] = ans;
        return ans;
    }
    public List<String> generateParenthesis(int n) {
       return generate(n);
    }
}