［leetcode] 95.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
题意：
这道题与96道题的区别是，96只需呀统计个数，而这道题是需要保存所有可能的树。
思路：
依旧采用动态规划的思路。对于DP[i][j]，在i到j之间选择一个数k作为根，那么会把这段数分成两段，即i->k-1,k+1->j,所以转移方程就是考虑子问题的组合。比如i->k－1,可能有m个子树，k+1->j可能有n个子树，那么对于以k为根，则需要构造m*n个子树，并保存在DP[i][j]中。当然DP[i][i] 就是只有一个元素，那么就只有一种情况。
以上。
代码如下：

/**
 * 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) {
        vector<TreeNode*> result;
        if(n == 0){
            result.push_back(NULL);
            return result;
        }
        vector<vector<vector<TreeNode*>>> DP(n);
        for(int i = 0; i < n; i++){
            vector<vector<TreeNode*>> temp(n); 
            DP[i] = temp;
            DP[i][i].push_back(new TreeNode(i + 1));
        }
        for(int j = 0; j < n; j++){
            for(int i = j - 1; i >= 0; i--){
                for(int k = i; k <= j ; k++){
                    if(k == i){
                        for(int m = 0; m < DP[k + 1][j].size(); m++){
                            TreeNode *root = new TreeNode(k + 1);
                            root->right = DP[k + 1][j][m];
                            DP[i][j].push_back(root);
                        }
                    }
                    else if(k == j){
                        for(int m = 0; m < DP[i][k - 1].size(); m++){
                            TreeNode *root = new TreeNode(k + 1);
                            root->left = DP[i][k - 1][m];
                            DP[i][j].push_back(root);
                        }
                    }
                    else{
                        for(int m = 0; m < DP[i][k-1].size(); m++)
                            for(int n = 0; n < DP[k+1][j].size(); n++){
                                TreeNode *root = new TreeNode(k+1);
                                root->left = DP[i][k-1][m];
                                root->right = DP[k+1][j][n];
                                DP[i][j].push_back(root);
                            }
                    }
                }
            }
        }
        return DP[0][n-1];
    }
};