LeetCode- 22. 括号生成

Posted 2021-08-11 ZSYL

22. 括号生成

• 题目描述
• 暴力枚举
• 回溯法
• 动态规划

题目描述

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

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

输入：n = 1
输出：["()"]

暴力枚举

暴力枚举所有可能的括号情况，n括号数2*n，使用char数组传参，便于回溯，枚举每一种情况。

检查括号是否有效，便是左括号右括号数是否相当，当 all < 0此时必然不等，提前return即可。

官方题解：

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> combinations = new ArrayList<>();
        genreateAll(new char[2*n], 0, combinations);
        return combinations;
    }
    public void genreateAll(char[] current, int pos, List<String> list) {
        // 递归结束条件
        if (pos == current.length) {
            if (valid(current)) {  // 判断括号序列是否合法
                list.add(new String(current));
            }
        } else {
            current[pos] = '(';  // 加入左括号
            genreateAll(current, pos+1, list);
            current[pos] = ')';  // 回溯，加入右括号
            genreateAll(current, pos+1, list);
        }
    }
    public boolean valid(char[] current) {
        int all = 0;
        for (char c : current) {
            if (c == '(')
                all++;
            else
                all--;
            if (all < 0)
                return false;
        }
        return all == 0;
    }
}

回溯法

方法一还有改进的余地：我们可以只在序列仍然保持有效时才添加 ‘(’ or ‘)’，而不是像 方法一 那样每次添加。我们可以通过跟踪到目前为止放置的左括号和右括号的数目来做到这一点，

如果左括号数量不大于 n，我们可以放一个左括号。如果右括号数量小于左括号的数量，我们可以放一个右括号。

StringBuiler：便于回溯，直接delete
ans：结果集
open：左括号数
close：右括号数
max：2*n（括号数）

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> ans = new ArrayList<>();
        backtrack(ans, new StringBuilder(), 0, 0, n);
        return ans;
    }
    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 (close < open) {
            cur.append(')');  // 加右括号
            backtrack(ans, cur, open, close+1, max);  // 递归树递归
            cur.deleteCharAt(cur.length()-1);  // 回溯，删除最后元素
        }
    }
}

另一种实现，使用字符串传参拼接，回溯时更方便，无需删除。
剩余左括号总数要小于等于右括号。 递归把所有符合要求的加上去就行。

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> ans = new ArrayList<>();
        backtrack(ans, "", n, n);
        return ans;
    }
    public void backtrack(List<String> ans, String cur, int open, int close) {
        // 递归终止条件
        if (open == 0 && close == 0) {
            ans.add(cur);  
            return;  
        }
            
        // 左括号可以一直加，因为右括号不停的跟
        if (open == close) {
            // 加左括号
            backtrack(ans, cur+'(', open-1, close);  // 递归树递归
        } else if (open < close) {
            if (open > 0) {
                // 加右括号
                backtrack(ans, cur+'(', open-1, close);  // 递归树递归
            }
            backtrack(ans, cur+')', open, close-1);  // 递归树递归
        }
    }
}

动态规划

Python：

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        if n == 0:
            return []
        total_l = []
        total_l.append([None])    # 0组括号时记为None
        total_l.append(["()"])    # 1组括号只有一种情况
        for i in range(2,n+1):    # 开始计算i组括号时的括号组合
            l = []        
            for j in range(i):    # 开始遍历 p q ，其中p+q=i-1 , j 作为索引
                now_list1 = total_l[j]    # p = j 时的括号组合情况
                now_list2 = total_l[i-1-j]    # q = (i-1) - j 时的括号组合情况
                for k1 in now_list1:  
                    for k2 in now_list2:
                        if k1 == None:
                            k1 = ""
                        if k2 == None:
                            k2 = ""
                        el = "(" + k1 + ")" + k2
                        l.append(el)    # 把所有可能的情况添加到 l 中
            total_l.append(l)    # l这个list就是i组括号的所有情况，添加到total_l中，继续求解i=i+1的情况
        return total_l[n]

Java：

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);
    }
}