95 Unique Binary Search Trees II

1 題目

Given an integer n, generate all structurally unique BST's (binary search trees) that store values 1 ... n.

Example:

Input: 3
Output:
[
  [1,null,3,2],
  [3,2,null,1],
  [3,1,null,null,2],
  [2,1,3],
  [1,null,2,null,3]
]
Explanation:
The above output corresponds to the 5 unique BST's shown below:

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

2 尝试解

class Solution {
public:
    vector<TreeNode*> generateTrees(int n) {
        vector<TreeNode*> result;
        map<pair<int,int>,vector<TreeNode*>> saver;
        if(n == 0) return result;
        result = getTree(1,n,saver);
        return result;
    }
    vector<TreeNode*> getTree(int start,int end, map<pair<int,int>,vector<TreeNode*>> &saver){
        if(saver.count(pair<int,int>{start,end}) != 0) return saver[pair<int,int>{start,end}];
        vector<TreeNode*> subtrees;
        if(start > end){
            TreeNode* root = NULL;
            subtrees.push_back(root);
            return subtrees;
        }
        for(int i = start; i<= end;i++){
            vector<TreeNode*> left = getTree(start,i-1,saver);
            vector<TreeNode*> right = getTree(i+1,end,saver);
            for(TreeNode* leftchild:left){
                for(TreeNode* rightchild:right){
                    TreeNode* root = new TreeNode(i);
                    root->left = leftchild;
                    root->right = rightchild;
                    subtrees.push_back(root);
                }
            }
        }
        return subtrees;
    }
};

3 标准解

class Solution {
public:
    vector<TreeNode *> generateTrees(int n) {
        vector<TreeNode*> res;
        if(n == 0) return res;
        return generateTree(1, n);
    }
    vector<TreeNode *> generateTree(int from, int to)
    {
        vector<TreeNode *> ret;
        if(to - from < 0) ret.push_back(0);
        if(to - from == 0) ret.push_back(new TreeNode(from));
        if(to - from > 0)
        {
            for(int i=from; i<=to; i++)
            {
                vector<TreeNode *> l = generateTree(from, i-1);
                vector<TreeNode *> r = generateTree(i+1, to);
    
                for(int j=0; j<l.size(); j++)
                {
                    for(int k=0; k<r.size(); k++)
                    {
                        TreeNode * h = new TreeNode (i);
                        h->left = l[j];
                        h->right = r[k];
                        ret.push_back(h);
                    }
                }
            }
        }
        return ret;
    }
};