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.

OJ‘s Binary Tree Serialization:

The serialization of a binary tree follows a level order traversal, where ‘#‘ signifies a path terminator where no node exists below.

Here‘s an example: 1 / \ 2 3 / 4 \ 5

The above binary tree is serialized as "{1,2,3,#,#,4,#,#,5}".

这道题的要求是用1...n生成结构不同的二叉搜索树（BST）。

二叉搜索树，顾名思义，它是一个二叉树，即每个节点下面最多有2个子节点。同时为了便于搜索的特性，二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树：

若其左子树不空，则左子树上所有结点的值均小于根结点的值；
若其右子树不空，则右子树上所有结点的值均大于根结点的值；
其左、右子树也分别为二叉搜索树。

这是对Unique Binary Search Trees的扩展，不是返回数目，而是需要生成所有情况的二叉搜索树。

1. 递归分治

要生成1...n的所有结构不同的二叉搜索树，可依次令根节点为1...n。假设当前根节点为i，则其左子树为1...i-1的所有结构不同的二叉搜索树，右子树为i+1...n的所有结构不同的二叉搜索树。因此，左右子树分别转化为两个子问题了，可以选择递归处理该子问题即可。

由于不同二叉搜索树的数量是卡特兰数，因此这道题的时间复杂度是卡特兰数。

时间复杂度：O(???)

空间复杂度：O(???)

 1 class Solution
 2 {
 3 public:
 4     vector<TreeNode *> generateTrees(int n)
 5     {
 6         return generateTrees(1, n);
 7     }
 8 private:
 9     vector<TreeNode *> generateTrees(int l, int r)
10     {
11         vector<TreeNode *> v;
12         
13         if(l > r)
14             v.push_back(NULL);
15         
16         for(int i = l; i <= r; ++ i)
17         {
18             vector<TreeNode *> vl = generateTrees(l, i - 1);
19             vector<TreeNode *> vr = generateTrees(i + 1, r);
20             for(int j = 0; j < vl.size(); ++ j)
21                 for(int k = 0; k < vr.size(); ++ k)
22                 {
23                     TreeNode *t = new TreeNode(i);
24                     t -> left = vl[j];
25                     t -> right = vr[k];
26                     v.push_back(t);
27                 }
28         }
29         
30         return v;
31     }
32 };

2. 动态规划

由于问题可以转化为子问题进行求解，因此可以选择记录已求解的子问题。记录存储的时候，为了降低空间复杂度，不采用dp[i][j]来存储i...j的所有情况，而采用dp[len]存储长度为len的所有情况，即1...len的所有情况。这样，在需要i+1...r的子问题解的情况时，需要对1...r-i的节点数值加上偏移i即可，即对dp[r-i]的所有情况加上偏移i。TreeNode * clone(TreeNode *root, int offset)函数的功能就是对root树中节点的数值进行加上偏移offset处理。

时间复杂度：O(???)

空间复杂度：O(???)

 1 class Solution
 2 {
 3 public:
 4     vector<TreeNode *> generateTrees(int n)
 5     {
 6         // dp[i]存储1...i的二叉搜索树
 7         vector<vector<TreeNode *> > dp(n + 1);
 8         dp[0].push_back(NULL);
 9         
10         for(int len = 1; len <= n; ++ len)
11             for(int i = 1; i <= len; ++ i)
12                 for(int l = 0; l < dp[i - 1].size(); ++ l)
13                     for(int r = 0; r < dp[len - i].size(); ++ r)
14                     {
15                         TreeNode *p = new TreeNode(i);
16                         p -> left = dp[i - 1][l];
17                         p -> right = clone(dp[len - i][r], i);
18                         dp[len].push_back(p);
19                     }
20         
21         return dp[n];
22     }
23 private:
24     TreeNode * clone(TreeNode *root, int offset)
25     {
26         if(root == NULL)
27             return NULL;
28         
29         TreeNode *p = new TreeNode(root -> val + offset);
30         p -> left = clone(root -> left, offset);
31         p -> right = clone(root -> right, offset);
32         return p;
33     }
34 };

LeetCode --- 95. Unique Binary Search Trees II

1. 递归分治

2. 动态规划