LeetCode Generate Parentheses DFS或者生产呢排列

https://leetcode.com/problems/generate-parentheses/

第一眼就感觉应该是生成排列，然后可以STL或者自己DFS， 时间复杂度O(n!) 简单起见 直接STL的next_permutation  注意这个函数的一个注意点，要想生成全部的排列，初始状态必须是字典序最小。

方法一： 32ms

class Solution {
public:
    bool check(string s){
        stack <char> sta;
        for(int i=0;i<s.size();i++) {
            if(s[i] == '(') {
                sta.push(s[i]);
            } else {
                if(sta.size()>0 && sta.top()=='(')sta.pop();
                else return false;
            }
        }
        if(sta.size() == 0) return true;
        else return false;
    }
    vector<string> generateParenthesis(int n) {
        string s;
        vector <string> ans;
        if(!n)return ans;
        for(int i=0;i<n;i++) {
            s = s + "(";
        }
        for(int i=0;i<n;i++) {
            s = s + ")";
        }
        do
        {
            if(check(s))ans.push_back(s);
            //ans.push_back(s);
        } while(next_permutation(s.begin(), s.end() ));
        return ans;
    }
};

然而32ms 感觉太丢人 于是DFS搞之

8ms

class Solution {
public:
    bool check(string s){
        stack <char> sta;
        for(int i=0;i<s.size();i++) {
            if(s[i] == '(') {
                sta.push(s[i]);
            } else {
                if(sta.size()>0 && sta.top()=='(')sta.pop();
                else return false;
            }
        }
        if(sta.size() == 0) return true;
        else return false;
    }
    vector<string> generateParenthesis(int n) {
        ans.clear();
        if(n == 0)return ans;
        dfs(n,n,"");
        return ans;
    }
    void dfs(int lcnt, int rcnt, string tmp) {
        if(lcnt == 0 && rcnt == 0) {
            if(check(tmp)) {
                ans.push_back(tmp);
                return ;
            }
        }
        //cout << "lcnt=" << lcnt << "  rcnt=" << rcnt << "  tmp=" << tmp <<endl;
        if(lcnt > rcnt)return ;
        if(lcnt)dfs(lcnt-1, rcnt, tmp+'(');
        if(rcnt)dfs(lcnt, rcnt-1, tmp+')');
    }

    vector <string> ans;
};

仍觉得丢人，于是抱着试试看的心态做了一个优化：

这么想，有几个条件是ans必须满足的：

（1）在构造解的过程中，每加一个字符都要保证 ( 个数大于或者等于 ) 的个数

（2）(的个数和)的个数相等。

那么这两个条件是不是ans的充要条件呢？ 必要性显然。 要证明充分性，只需要证明满足这两个条件就一定是解。

严格证明我还没搞定，但是参照这个

http://blog.youkuaiyun.com/u011026968/article/details/50364900   的做法  可以模拟看看

于是得到4ms的代码 也非常简洁  然而感觉也许有更快的代码，求赐教

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        ans.clear();
        if(n == 0)return ans;
        dfs(n,n,"");
        return ans;
    }
    void dfs(int lcnt, int rcnt, string tmp) {
        if(lcnt == 0 && rcnt == 0) {
            ans.push_back(tmp);
            return ;
        }
        if(lcnt > rcnt)return ;
        if(lcnt)dfs(lcnt-1, rcnt, tmp+'(');
        if(rcnt)dfs(lcnt, rcnt-1, tmp+')');
    }
    vector <string> ans;
};