22 Generate Parentheses

给定数字，然后产生所有括号的嵌套组合

输入：n

输出：括号的字符串

注意事项：括号必须正确闭合和嵌套

思路：这种感觉有点像之前那个电话号码。就是遍历产生的那个。但是这个有点不一样就是所有的括号都是相同的，找的是括号的嵌套方式的不同。还要保证括号的正确闭合。加入将括号看成三个节点，就是互相成为子节点。也就是组成树的所有组合方式。之前那个用栈来解决了，这个可不可以呢。用递归呢，要产生n的树，就在n-1上加一个节点。

实际太复杂，由于能力所限制，看解析

 

第一个方法：暴力法，直接生成所有的序列，然后判断是否合适。

这个。。。emmm。。。。我怎么就没想到呢。不过时间复杂度显然很高，算了吧

    vector<string> generateParenthesis(int n) {
        unordered_set<string> myStrs = insertParen(n);
        vector<string>result;
        for(string str: myStrs){
            result.push_back(str);
        }
        sort(result.begin(),result.end());
        return result;
    }
   
    string insert(int pos, string target, string obj){
        if(pos == 0) return obj+target;
        if(pos == target.size()) return target+obj;
        if(pos > target.size()) return "";
        return target.substr(0, pos)+ obj+ target.substr(pos, target.size()-pos);
    }
    
    unordered_set<string> insertParen(int n){
        if(n == 1) return {"()"};
        unordered_set<string> result;
        unordered_set<string> myStrs = insertParen(n-1);
        for(string str: myStrs){
            int len = str.size();
            for(int i = 0; i<len+1; i++){
                result.insert(insert(i, str, "()" ));
            }
        }
        return result;
    }

执行用时 : 20 ms, 在Generate Parentheses的C++提交中击败了8.10% 的用户

内存消耗 : 10.6 MB, 在Generate Parentheses的C++提交中击败了1.66% 的用户

思路，插空。利用将括号插到任意位置，递归增加，将所有可能的正确的子串产生，用hash_set来存储以避免重复。排序，得到结果。

别的思路：

   void Next(vector<string> &returnAns, string ans, int count1, int count2, int n) {
        if (count1>n||count2>n||count2>count1) return;
        if (count1==n&&count2==n) {
            returnAns.push_back(ans);
            return;
        }
        Next(returnAns, ans+"(", count1+1, count2, n);
        Next(returnAns, ans+")", count1, count2+1, n);
        return;
    }
 
    vector<string> generateParenthesis(int n) {
        vector<string> returnAns;
        int count1=0;
        int count2=0;
        Next(returnAns, "", count1, count2, n);
        return returnAns;
        
    }
 

这就是传说中的回溯法。count1 count2分别记录"("和"("的数目。

当且仅当count1<= count2 的时候，该序列为有效序列。让count1 或者 count2 > n则该序列无效。从而将所有正确的字符串都给体现了出来。