LeetCode Unique Binary Search Trees II

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

For example,
Given n = 3, your program should return all 5 unique BST's shown below.

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

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

class Solution {
private:
    vector<TreeNode *> res;
public:
    vector<TreeNode *> generateTrees(int n) {
        res.clear();
        res = dfs(1, n + 1);
        return res;
    }

    vector<TreeNode*> dfs(int start, int end) {
        vector<TreeNode*> res;
        if (start >= end) {
            res.push_back(NULL);
            return res;
        }
        TreeNode* rt = NULL;
        for (int i=start; i<end; i++) {
            vector<TreeNode*> lsub = dfs(start, i);
            vector<TreeNode*> rsub = dfs(i+1, end);

            for (int li=0; li<lsub.size(); li++) {
                for (int ri=0; ri<rsub.size(); ri++) {
                    rt = new TreeNode(i);
                    rt->left = lsub[li];
                    rt->right= rsub[ri];
                    res.push_back(rt);
                }
            }
        }
        return res;
    }
};

递归真是个好东西！

第二轮：

写一个非递归的，不过感觉内存占用应该会大许多吧

/**
 * 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*> generateTrees(int n) {
        unordered_map<long, vector<TreeNode*> > dp;
        
        dp.insert(make_pair(0, vector<TreeNode*>(1, NULL)));
        
        for (int k=0; k<=n; k++) {
            for (int i=0; (i + k) <= n; i++) {
                int from = i, to = i + k;
                vector<TreeNode*> trees;
                for (int r = from; r<=to; r++) {
                    vector<TreeNode*>& lsub = dp[id(from, r-1)];
                    vector<TreeNode*>& rsub = dp[id(r+1, to)];
                    
                    for (TreeNode* lsubroot : lsub) {
                        for (TreeNode* rsubroot: rsub) {
                            TreeNode* root = new TreeNode(r);
                            root->left = lsubroot;
                            root->right= rsubroot;
                            trees.push_back(root);
                        }
                    }
                }
                dp.insert(make_pair(id(from, to), trees));
            }
        }
        return dp[id(1, n)];
    }
    
    long id(long from, long to) {
        return from > to ? 0 : (from<<32)|to;
    }
};