leetcode 22. 括号生成 暴力/递归回溯 忘写return居然速度提高？

记着要返回上一级递归 不然会内存泄露

#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
using namespace std;
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;
	}
};

int main()
{

	Solution a;
	a.generateParenthesis(4);
	int i = 1;
	system("pause");
	return 0;
}

生成的string依次是






等等

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;
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/generate-parentheses/solution/gua-hao-sheng-cheng-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
    shared_ptr<vector<string>> cache[100] = {nullptr};
public:
    shared_ptr<vector<string>> generate(int n) {
        if (cache[n] != nullptr)
            return cache[n];
        if (n == 0) {
            cache[0] = shared_ptr<vector<string>>(new vector<string>{""});
        } else {
            auto result = shared_ptr<vector<string>>(new vector<string>);
            for (int i = 0; i != n; ++i) {
                auto lefts = generate(i);
                auto rights = generate(n - i - 1);
                for (const string& left : *lefts)
                    for (const string& right : *rights)
                        result -> push_back("(" + left + ")" + right);
            }
            cache[n] = result;
        }
        return cache[n];
    }
    vector<string> generateParenthesis(int n) {
        return *generate(n);
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/generate-parentheses/solution/gua-hao-sheng-cheng-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

自己写的

暴力法

class Solution {
public:
    bool isvalid(string &cur){
        int num=cur.size();
        int bal=0;
        int i=0;
        while(i<num&&bal>=0) {
            if(cur[i]=='(') {
                bal++;
                i++;
            }
            else if(cur[i]==')'){
                bal--;
                i++;
            }
            if(i==num&&bal==0){
                return true;
            }
        }
        return false;
    }
    void allstring(vector<string> &ans,string &cur,int n){
        if(n==cur.size()){
            if (isvalid(cur)) ans.push_back(cur);
            return;
            
        }
        cur+='(';
        allstring(ans,cur,n);
        cur.pop_back();
        cur+=')';
        allstring(ans,cur,n);
        cur.pop_back();        
    }
    vector<string> generateParenthesis(int n) {
        //暴力法
        //设置一个保存结果的数组
        vector<string> ans;
        //当前尝试的string
        string cur;
        allstring(ans,cur,2*n);
        return ans;
    }
};

回溯法（有条件递归）

忘记写return了 居然速度还提高了 没懂为啥

class Solution {
public:
    void generate(vector<string> &ans,string &cur,int n,int open,int close){
        if(cur.size()==n*2){
            ans.push_back(cur);
        }
        if(open<n){
            cur+='(';
            generate(ans,cur,n,open+1,close);
            cur.pop_back();
        }
        if(close<open){
            cur+=')';
            generate(ans,cur,n,open,close+1);
            cur.pop_back();
        }
    }
    vector<string> generateParenthesis(int n) {
        //答案数组
        vector<string> ans;
        //存储每一个答案的字符串
        string cur;
        generate(ans,cur,n,0,0);
        return ans;
    }
};