刷题记录：括号生成

括号生成

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        ans = []
        self.parenthesis = ""
        def backtracking(n_left,n_right,level):
            if level == 2*n:
                ans.append(copy.deepcopy(self.parenthesis))
                return
            
            #选择列表
            for parenthesis in ['(',')']:
                if parenthesis == '(' and n_left < n:
                    # do choice
                    self.parenthesis = self.parenthesis + '('
                    # backtracking
                    backtracking(n_left+1,n_right,level+1)
                    # cancel
                    self.parenthesis = self.parenthesis[:-1]
                if parenthesis == ')' and n_right < n and n_left > n_right:
                    self.parenthesis = self.parenthesis + ')'
                    backtracking(n_left,n_right+1,level+1)
                    self.parenthesis = self.parenthesis[:-1]
        backtracking(0,0,0)
        return ans

简介版本：py / c++
py

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        ans = list()
        def backtracking(level, cur, n_l, n_r):
            if level == 2 * n:
                ans.append(cur)
                return
            
            for par in ['(', ')']:
                if par == '(' and n_l < n:
                    backtracking(level + 1, cur + '(', n_l + 1, n_r)
                elif par == ')' and n_r < n and n_l > n_r:
                    backtracking(level + 1, cur + ')', n_l, n_r + 1)
        backtracking(0, "", 0, 0)
        return ans

c++

class Solution {
    void backtrack(vector<string>& ans, string& cur, int n_l, int n_r, int level, int n){
        if(level == 2 * n){
            ans.push_back(cur);
            return;
        }
        for(char par:{'(', ')'}){
            if(par == '(' && n_l < n){
                cur.push_back('(');
                backtrack(ans, cur, n_l + 1, n_r, level + 1, n);
                cur.pop_back();
            }else if(par == ')' && n_r < n && n_r < n_l){
                cur.push_back(')');
                backtrack(ans, cur, n_l, n_r + 1, level + 1, n);
                cur.pop_back();
            }
        }
    }
public:
    vector<string> generateParenthesis(int n) {
        vector<string> ans;
        string cur;
        backtrack(ans, cur, 0, 0, 0, n);
        return ans;
    }
};