95. Unique Binary Search Trees II

/**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
//[3,1,4,null,2,null,5],[3,1,5,null,2,4],[3,2,4,1,null,null,5],[3,2,5,1,null,4],
//failed
class Solution {
public:
TreeNode* copy_tree(TreeNode* root)
{
if(!root) return NULL;
TreeNode* temp=new TreeNode(root->val);
temp->left=copy_tree(root->left);
temp->right=copy_tree(root->right);
return temp;
}
int inorder(TreeNode* root,int i)
{
if(root->left) i=inorder(root->left,i);
root->val=i++;
if(root->right) i=inorder(root->right,i);
return i;
}
void get_tree(vector<TreeNode*>& v,TreeNode* root,TreeNode* temp,int i,int n)
{
if(i>n)
{
inorder(root,1);
v.push_back(copy_tree(root));
//if(v.size()==3) cout<<root->right->right->val;
//cout<<root->left->left->val;
//v.push_back(root);
return;
}
TreeNode* tmp=new TreeNode(i);
if(temp->left) //
{
temp->right=tmp;
get_tree(v,root,temp->left,i+1,n);
if(i<n) get_tree(v,root,temp->right,i+1,n);
temp->right=NULL;
}
else
{
temp->left=tmp;
get_tree(v,root,tmp,i+1,n);
if(i<n) get_tree(v,root,temp,i+1,n);
temp->left=NULL;

temp->right=tmp;
get_tree(v,root,tmp,i+1,n);
temp->right=NULL;
}
delete tmp;
}
vector<TreeNode*> generateTrees(int n) {
if(n==0) return {};
vector<TreeNode*> v;
TreeNode* tmp=new TreeNode(1);
get_tree(v,tmp,tmp,2,n);
return v;
}
};

/**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
//failed
class Solution {
public:
TreeNode* copy_tree(TreeNode* root)
{
if(!root) return NULL;
TreeNode* temp=new TreeNode(root->val);
temp->left=copy_tree(root->left);
temp->right=copy_tree(root->right);
return temp;
}
void inorder(TreeNode* root)
{
if(root->left) inorder(root->left);
root->val++;
if(root->right) inorder(root->right);
}
void outorder(TreeNode* root)
{
if(root->left) outorder(root->left);
root->val--;
if(root->right) outorder(root->right);
}
void get_tree(vector<TreeNode*>& v,TreeNode* root,TreeNode* temp,int i,int n)
{
if(i>n)
{
//inorder(root,1);
v.push_back(copy_tree(root));
return;
}
TreeNode* tmp=new TreeNode(i);
//make it the root

tmp->left=root;
get_tree(v,tmp,tmp,i+1,n);
tmp->left=NULL;
if(temp->left&&(temp->left->left||temp->left->right))
{
inorder(root);
tmp->val=1;

tmp->right=root;
get_tree(v,tmp,temp,i+1,n);
tmp->right=NULL;
if(!root->left)
{
root->left=tmp;
get_tree(v,root,temp,i+1,n);
root->left=NULL;
}
tmp->val=i;
outorder(root);
}
//make it the rightest
temp->right=tmp;
get_tree(v,root,tmp,i+1,n);
temp->right=NULL;

if(!temp->left&&temp!=root)
{
temp->left=tmp;
temp->val=i;
tmp->val=i-1;
get_tree(v,root,temp,i+1,n);
temp->left=NULL;
temp->val=i-1;
}
delete tmp;
}
vector<TreeNode*> generateTrees(int n) {
if(n==0) return {};
vector<TreeNode*> v;
TreeNode* tmp=new TreeNode(1);
get_tree(v,tmp,tmp,2,n);
return v;
}
};

/**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector<TreeNode*> get_tree(int l,int r)
{
if(l>r) return {NULL};
vector<TreeNode*> v;
for(int i=l;i<=r;i++)
{
vector<TreeNode*> left=get_tree(l,i-1);
vector<TreeNode*> right=get_tree(i+1,r);
for(auto a=left.begin();a!=left.end();a++)
{
for(auto b=right.begin();b!=right.end();b++)
{
TreeNode* temp=new TreeNode(i);
temp->left=*a;
temp->right=*b;
v.push_back(temp);
}
}
}
return v;
}
vector<TreeNode*> generateTrees(int n) {
if(n==0) return {};
return get_tree(1,n);
}
};