【刷题】day2_leetcode22题（回溯法+动态规划）

问题描述：

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

示例：

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

用两种方法解：
1.回溯法

一般回溯的问题有三种：
（1）Find a path to success 有没有解
（2）Find all paths to success 求所有解
求所有解的个数
求所有解的具体信息
（3）Find the best path to success 求最优解

回溯法一般使用两个变量： res 和 path，res 表示最终的结果，path 保存已经走过的路径。如果搜到一个满足要求的path，就把 path 放到 res 中。

这个题中剪枝的条件
1."(“加入当前路径的条件：
左子树的个数<n
2.”)“加入当前路径的条件：
右子树的个数<n，且”(“的数量多于”)"。

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> res;
        int lc=0,rc=0;
        string cur = "";//记录当前路径
        dfs(res,lc,rc,cur,n);
        return res;
    }
    void dfs(vector<string> &res,int lc,int rc,string cur,int n){
        /*搜索出口*/
        if(lc==n&&rc==n){
            res.push_back(cur);
            return;
        }
        if(lc<n){
            cur+="(";
            dfs(res,lc+1,rc,cur,n);
            cur.pop_back();
        }
        if(lc>rc&&rc<n){
            cur+=")";
            dfs(res,lc,rc+1,cur,n);
            cur.pop_back();
        }
    }

};

2.动态规划
求n对括号的组合方式，其实就是在n-1对括号的组合方式的基础上求解，但是如果直接考虑n-1的括号的组合方式会很复杂，所以可以逆向求解，将括号的位置定下来，考虑(A)B的不同情况。
求i对括号的组合情况时，序列A的长度a从0到i-1变化，序列B的长度b从i-1到0变化，即a+b=i-1。用dp[i]来储存之前已经求解过的长度为i的组合情况。

为什么这种方法不会重复，因为dp[i]中不会有重复的，代表了i对括号的组合情况，而只要p1!=p2,就有（p1）q1！=（p2）q2。（这里的p、q表示长度）

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<vector<string>> dp;//dp[i]代表i对括号的组合情况
        vector<string> tmp;
        tmp.push_back("");
        dp.push_back(tmp);
        tmp.clear();
        tmp.push_back("()");
        dp.push_back(tmp);
        //A的长度从i-1到0，B从0到i-1，求(A)B的组合情况 
        for(int i=2;i<=n;i++){
            vector<string> tmp;
            for(int a=i-1;a>=0;a--){
                string l = "";
                int b =i-1-a;
                for(int j =0;j<dp[a].size();j++){
                    for(int k=0;k<dp[b].size();k++){
                        l = "("+dp[a][j]+")"+dp[b][k];
                        tmp.push_back(l);
                    }
                }
            }
            dp.push_back(tmp);
        }
        return dp[n];
    }
};

默默说一句，本问题和求1-n可能的出栈顺序是差不多的，遇见相似问题可以迁移。