22. 括号生成

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

示例 1：

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

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

提示：

1 <= n <= 8

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

官方题解：

方法一：暴力法
思路

class Solution {
    bool valid(const string& str) {
        int balance = 0;
        for (char c : str) {
            if (c == '(') {
                ++balance;
            } else {
                --balance;
            }
            if (balance < 0) {
                return false;
            }
        }
        return balance == 0;
    }

    void generate_all(string& current, int n, vector<string>& result) {
        if (n == current.size()) {
            if (valid(current)) {
                result.push_back(current);
            }
            return;
        }
        current += '(';
        generate_all(current, n, result);
        current.pop_back();
        current += ')';
        generate_all(current, n, result);
        current.pop_back();
    }
public:
    vector<string> generateParenthesis(int n) {
        vector<string> result;
        string current;
        generate_all(current, n * 2, result);
        return result;
    }
};

class Solution {
    void backtrack(vector<string>& ans, string& cur, int open, int close, int n) {
        if (cur.size() == n * 2) {
            ans.push_back(cur);
            return;
        }
        if (open < n) {
            cur.push_back('(');
            backtrack(ans, cur, open + 1, close, n);
            cur.pop_back();
        }
        if (close < open) {
            cur.push_back(')');
            backtrack(ans, cur, open, close + 1, n);
            cur.pop_back();
        }
    }
public:
    vector<string> generateParenthesis(int n) {
        vector<string> result;
        string current;
        backtrack(result, current, 0, 0, n);
        return result;
    }
};

 递归的出口是当前字符串的尺寸是两倍的n时，将当前字符串加入ans并返回，此处并没有在最后判断生成的字符串是否有效，因为回溯法已经在一边生成字符串的过程中一边判断当前字符串是否有效了，首先要保证字符串有效，左括号和右括号的数量是有限制的，不能超出这个限制，然后要在添加最后一个字符前，左括号数量总大于右括号数量（可以在草稿纸上画画找出该规律）。

这题怎么都写不出来。。对回溯还是不太熟悉，最后是边看题解边写的代码：

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        
        if (n == 0)return {};

        vector<string> ans;
        string s;
        caTch(ans, s, 0, n, n, n);
        return ans;
        
    }
    
    //lt和rt代表的是还没有用到的括号数量。。
    void caTch (vector<string> &ans,string &s, int x,int n,int lt,int rt)
    {
        if (x==2*n)
        {
                ans.push_back(s);
                return;
        }

        if (lt != 0)
        {
            s.push_back('(');
            caTch(ans,s, x + 1, n, lt - 1, rt);
            s.pop_back();
        }
        
        //没有用到的右括号数量大于左括号的，说明当前字符串左括号数量大于右括号的
        if (rt>lt)
        {
            s.push_back(')');
            caTch(ans,s, x + 1, n, lt, rt - 1);
            s.pop_back();
        }
    }

    //这个是照搬20题的代码的，本题用不上，可忽略
    bool isValid(string t)
    {
        int lenth = t.size();
        pair<char, char>n1 = { '(',')' };

        stack<char> stk;
        for (char c : t)
        {
            if (c == n1.second)
            {
                if (stk.empty() || stk.top() != n1.first)return false;
                else stk.pop();
            }
            else
            {
                stk.push(c);
            }
        }

        return stk.empty();
    }
};