力扣 22. 括号生成🔗 https://leetcode.cn/problems/generate-parenthe

题目

生成 n 对所有的有效括号组合

思路

回溯，在递归函数的设计上，用了两种办法
solution 1，枚举当前可以添加（括号的所有可能性，在此基础之上，再枚举可以添加）括号的所有可能性，递归下去，递归结束之后，reset；
因为这样枚举可能会有重复的组合，用 set 进行判重
solution 1，枚举当前位置，要么添加一个（，要么添加一个），递归到 2 * n + 1 的位置结束
这样枚举没有重复的情况，好理解，效率高，代码清洗

代码

class Solution {
public:
    unordered_set<string> s;
    void dfs(vector<string>& ans, string& curr, int n, int l, int r) {
        if (r == n) {
            if (s.count(curr)) return;
            ans.push_back(curr);
            s.insert(curr);
            return;
        }
        if (l == n) {
            for (int i = 0; i < n - r; i++) {
                curr += ")";
            }
            dfs(ans, curr, n, n, n);
            for (int i = 0; i < n - r; i++) {
                curr.pop_back();
            }
            return;
        }
        for (int i = 0; i < n - l; i++) {
            for (int k = 0; k < i + 1; k++) {
                curr += "(";
            }
            for (int j = 0; j <= l - r + i + 1; j++) {
                for (int k = 0; k < j; k++) {
                    curr += ")";
                }
                dfs(ans, curr, n, l + i + 1, r + j);
                for (int k = 0; k < j; k++) {
                    curr.pop_back();
                }
            }
            for (int k = 0; k < i + 1; k++) {
                curr.pop_back();
            }
        }
    }
    vector<string> solution1(int n) {
        vector<string> ans;
        string curr;
        dfs(ans, curr, n, 0, 0);
        return ans;
    }

    void backtracing(vector<string>& ans, string& curr, int n, int l, int r) {
        if (r == n) {
            ans.push_back(curr);
            return;
        }

        if (l < n) {
            curr += "(";
            backtracing(ans, curr, n, l + 1, r);
            curr.pop_back();
        }

        if (l > r) {
            curr += ")";
            backtracing(ans, curr, n, l, r + 1);
            curr.pop_back();
        }
    }

     vector<string> solution2(int n) {
        vector<string> ans;
        string curr;
        backtracing(ans, curr, n, 0, 0);
        return ans;
     }

    vector<string> generateParenthesis(int n) {
        return solution2(n);
        
    }
};