vector<string> generateParenthesis(int n) {
if (n==1) {
vector<string> rt_val;
rt_val.push_back("()");
return rt_val;
} else if (n==2) {
vector<string> rt_val;
rt_val.push_back("()()");
rt_val.push_back("(())");
return rt_val;
} else {
unordered_set<string> p_set;
vector<string> left;
vector<string> right;
left = generateParenthesis(n-1);
for (auto x : left) {
p_set.insert('('+x+')');
}
for (int i=1; i<n; ++i) {
left = generateParenthesis(i);
right = generateParenthesis(n-i);
for (auto x : left) {
for (auto y : right) {
p_set.insert(x+y);
}
}
}
left.clear();
for (auto k : p_set) {
left.push_back(k);
}
return left;
}
}
vector<string> generateParenthesis(int l, int r, int lQ, int rQ, int len)
{
vector<string> ret;
if(len == 0) return ret;
if(lQ > rQ && r > 0)
{
vector<string> v = generateParenthesis(l, r-1, lQ, rQ+1, len-1);
string s = ")";
int i;
for(i=0; i< v.size(); i++)
{
ret.push_back(s + v[i]);
}
if(i == 0)
ret.push_back(s);
}
if(l > 0)
{
vector<string> v = generateParenthesis(l-1, r, lQ+1, rQ, len-1);
string s = "(";
int i;
for(i=0; i< v.size(); i++)
{
ret.push_back(s+ v[i]);
}
if(i == 0)
ret.push_back(s);
}
return ret;
}
void generateParenthesis(vector<string> &res, string s, int n, int left_paren, int right_paren){
if(right_paren==n){
res.push_back(s);
return ;
}
if(!left_paren){
s+='(';
left_paren++;
generateParenthesis(res, s, n, left_paren, right_paren);
s.pop_back();
}
else{
if(left_paren<n){
s+='(';
left_paren++;
generateParenthesis(res, s, n, left_paren, right_paren);
s.pop_back();
left_paren--;
}
if(right_paren<left_paren){
s+=')';
right_paren++;
generateParenthesis(res, s, n, left_paren, right_paren);
s.pop_back();
right_paren--;
}
}
}
vector<string> generateParenthesis(int n) {
if(n==0) return vector<string>(1,"") ;
if(n==1) return vector<string>(1,"()") ;
vector<string> result;
for(int i=0;i!=n;i++)
for(auto inner: generateParenthesis(i))
for(auto outter: generateParenthesis(n-i-1))
result.push_back("("+inner+")"+outter);
return result;
}
void generateParenthesis(string str, int left, int right, vector<string> &ret)
{
if (left == 0 && right == 0)
{
ret.push_back(str);
return;
}
if (left > 0) generateParenthesis(str + "(", left - 1, right, ret);
if (right > left) generateParenthesis(str + ")", left, right - 1, ret);
}
void generateParenthesis(int left, int right, vector<string>&res, string tmp) {
if (left == 0 && right == 0) {
res.push_back(tmp); return;
}
if (left > 0) {
generateParenthesis(left - 1, right, res, tmp + "(");
}
if (right > left) {
generateParenthesis(left, right - 1, res, tmp + ")");
}
}
void generateParenthesis(int n, int left, int right, string s,
vector<string>& result) {
if (left == n && right == n) {
result.push_back(s);
return;
}
if (left < n) {
generateParenthesis(n, left+1, right, s + "(", result);
}
if (right < left) {
generateParenthesis(n, left, right+1, s + ")", result);
}
}
void generateParenthesis(vector<string> &res, string s, int n, int left){
if(!n){
res.push_back(s);
return ;
}
if(!left)
generateParenthesis(res, s+'(', n, left+1);
else{
if(left<n)
generateParenthesis(res, s+'(', n, left+1);
generateParenthesis(res, s+')', n-1, left-1);
}
}
void generateParenthesis(int left, int right, string s, vector<string> &ans) {
if(left == 0 && right == 0) {
ans.push_back(s);
return;
}
// there are still remaining '('s
if(left > 0) {
generateParenthesis(left-1, right, s+'(', ans);
}
// for every '(', there is a ')'
if(right > left) {
generateParenthesis(left, right-1, s+')', ans);
}
}
void generateParenthesis(vector<string> &res, int left,int right,string cur,int n){
if(right == n)
res.push_back(cur);
if(left < n){
left ++;
generateParenthesis(res,left,right,cur + string("("), n);
left --;
}
if(right < left){
right ++;
generateParenthesis(res,left,right,cur + string(")"), n);
right --;
}
}
vector<string> generateParenthesis(int n) {
vector<string> result;
if (n < 1) return result;
int lc(0);
int rc(0);
return generateParenthesis(n, lc, rc);
}
int main(void)
{
int n;
char **res;
res = generateParenthesis(1, &n);
return(0);
}
vector<string> generateParenthesis(int n) {
if(n == 0) {
vector<string> res;
res.clear();
res.push_back("");
return res;
}
vector<string> last = generateParenthesis(n - 1);
vector<string> res;
res.clear();
set<string> res1;
res1.clear();
for(int i = 0; i < last.size(); ++i) {
int len = 2 * (n - 1);
for(int j = 0; j <= len; ++j) {
string tmp = last[i];
tmp.insert(j, "()");
res1.insert(tmp);
}
}
for(auto it = res1.begin(); it != res1.end(); it++) {
res.push_back(*it);
}
return res;
}
vector<string> generateParenthesis(int n) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if (n==0){
return vector<string> (1,"");
}else if (n==1){
return vector<string> (1,"()");
}
vector<string> vs_short = generateParenthesis(n-1);
vector<string> vs(0);
for (int i=0; i<vs_short.size(); ++i){
string s = vs_short[i];
int stk = 0;
for (int j=0; j<s.size(); ++j){
if (stk==0){
vs.push_back("("+s.substr(0,j)+")"+s.substr(j,s.size()-j));
}
if (s[j]=='('){
stk++;
}else if (s[j]==')'){
stk--;
}
}
vs.push_back("("+s+")");
}
return vs;
}
/**
* @param n n pairs
* @return All combinations of well-formed parentheses
*/
vector<string> generateParenthesis(int n) {
// Write your code here
vector<string> answers;
string parenthesis;
generateParenthesis(0, parenthesis, n, answers);
return answers;
}
vector<string> generateParenthesis(int n) {
if (n == 0) return vector<string>(1, "");
if (n == 1) return vector<string>(1, "()");
if (Cache.count(n)) return Cache[n];
vector<string> result;
for (int i = 0; i < n; ++i) {
vector<string> a = generateParenthesis(i), b = generateParenthesis(n - 1 - i);
for (int j = 0; j < a.size(); ++j) {
for (int k = 0; k < b.size(); ++k) {
result.push_back("(" + a[j] + ")" + b[k]);
}
}
}
Cache[n] = result;
return result;
}
void generateParenthesis(int left, string &parenthesis, const int n, vector<string> &answers) {
if (left == n && parenthesis.length() == n + n) {
answers.push_back(parenthesis);
return;
}
if (left < n) {
parenthesis += '(';
generateParenthesis(left + 1, parenthesis, n, answers);
parenthesis.pop_back();
}
if (left + left > parenthesis.length()) {
parenthesis += ')';
generateParenthesis(left, parenthesis, n, answers);
parenthesis.pop_back();
}
}
void generateParenthesis(int n, int left, int right, string& s) {
if (left == n && right == n) {
r.push_back(s);
return;
}
if (right < left) {
s.push_back(')');
generateParenthesis(n, left, right + 1, s);
s.pop_back();
}
if (left < n) {
s.push_back('(');
generateParenthesis(n, left + 1, right, s);
s.pop_back();
}
}
void generateParenthesis(int iNumber, set<string> & setResult)
{
if (iNumber <= 0)
{
return;
}
if (iNumber == 1)
{
setResult.insert("()");
return;
}
set<string> setPrevResult;
generateParenthesis(iNumber - 1, setPrevResult);
for (set<string>::iterator setIterator = setPrevResult.begin(); setIterator != setPrevResult.end(); setIterator ++)
{
for (int iIndex = 0; iIndex < (*setIterator).length(); iIndex ++)
{
setResult.insert((*setIterator).substr(0, iIndex) + "()" + (*setIterator).substr(iIndex));
}
setResult.insert((*setIterator) + "()");
}
}
vector<string> generateParenthesis(int n) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
vector<string> ret;
if(n == 0) return ret;
ret = generateParenthesis(n, n, 0, 0, 2*n);
return ret;
}
int main()
{
char **result;
int returnSize;
result=generateParenthesis(3,&returnSize);
print_arr_arr((int **)result,returnSize,3);
return 0;
}
vector<string> generateParenthesis(int n) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
r.clear();
string s;
generateParenthesis(n, 0, 0, s);
return r;
}
// second version -- without right_paren
vector<string> generateParenthesis(int n) {
vector<string> res;
if(n){
string s;
generateParenthesis(res, s, n, 0);
}
return res;
}
vector<string> generateParenthesis(int n) {
vector<string> ret;
int rever_n = 0;
int i = n;
string str;
generateParenthesis(ret, str, 2*n, i, rever_n, 0);
return ret;
}
void testGenerateParenthesis(){
int count = 0;
char** result = generateParenthesis(3,&count);
for(int i = 0; i < count;i++){
printf("%s,",result[i]);
}
}
vector<string> generateParenthesis(int n) {
vector<string> ans;
if(n == 0) {
return ans;
}
string s;
generateParenthesis(n, n, s, ans);
return ans;
}
// first version
vector<string> generateParenthesis(int n) {
vector<string> res;
if(n){
string s;
int left_paren=0, right_paren=0;
generateParenthesis(res, s, n, left_paren, right_paren);
}
return res;
}
// refer to unique binary search trees II
// Key: a possible parenthesis = i outer()s + ( + n-i-1 inner()s + )
vector<string> generateParenthesis(int n) {
vector<string> parens;
if(n==0) {
parens.push_back("");
return parens;
}
if(n==1) {
parens.push_back("()");
return parens;
}
for(int i=0; i<n; i++){
for(string outer : generateParenthesis(i)){
for(string inner : generateParenthesis(n-i-1)){ // here, think carefully
parens.push_back(outer+"("+inner+")");
}
}
}
return parens;
}
vector<string> generateParenthesis(int n, int lc, int rc) {
if (rc == n) return vector<string>(1, "");
vector<string> res;
// option 1 : put (
if (lc < n) {
vector<string> tmp = generateParenthesis(n, lc+1, rc);
for (int i = 0; i < tmp.size(); ++i) {
res.push_back("(" + tmp[i]);
}
}
if (lc > rc) {
// if left count > right count, can put )
vector<string> tmp = generateParenthesis(n, lc, rc+1);
for (int i = 0; i< tmp.size(); ++i) {
res.push_back(")" + tmp[i]);
}
}
return res;
}
void generateParenthesisMain(voia){
int returnSize = 0;
char** result = generateParenthesis(4, &returnSize);
while(returnSize>0){
printf("%s\n", result[returnSize-1]);
free(result[returnSize-1]);
returnSize--;
}
free(result);
}
