題目描述：

96.Unique Binary Search Trees

Given n, how many structurally unique BST's (binary search trees) that store values 1 ... n?

Example:

Input: 3
Output: 5
Explanation:
Given n = 3, there are a total of 5 unique BST's:

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

95.Unique Binary Search Trees II

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
 

演算法實現：

先實現第96題,

可以採用遞迴的思路解決，對於n的問題，可以選取1到n的任意一個元素i作為根節點，其左右子樹分別是元素個數位i - 1和 n - i的二叉搜尋樹

直接遞迴超時，因為有一些重複運算；故在此基礎上略微改造，改造為動態規劃的方法

// 純遞迴的方式，但是進行了很多次重複運算，比如n=10，那麼i取4，5，6，7，...8，9時都要計算numTrees(3)，造成了時間的浪費
// class Solution {
// public:
//     int numTrees(int n) {
//         int suanz = 0;
//         if(n == 0 || n == 1)return 1;
//         for(int i = 0; i < n; i++)
//             suanz += numTrees(i) * numTrees(n - i - 1);
//         return suanz;
//     }
// };

// 是一種通過遞迴改造來的動態規劃的方式，將計算過的numTrees(i)存在res[i]中，依次計算res[0],res[1],...res[n]
// 這也就變成了Catalan Number卡特蘭數的一個例子
class Solution {
public:
    int numTrees(int n) {
        int suanz = 0;
        if(n == 0 || n == 1)return 1;
        vector<int> res(n + 1,0);
        res[0] = 1;
        res[1] = 1;
        for(int j = 2; j <= n; j ++){
            for(int i = 0; i < j; i++)
                res[j] += res[i] * res[j - i - 1];
        }        
        return res[n];
    }
};
 

之後是第95題

思路是一樣的，只不過第96題的左右兩側的子樹求的是種類數，這個問題是要將所有的種類列舉出來

為了提高效率，進行了一點優化，對於已經生成的情況的子樹，不在重複計算(程式中有註釋解釋)

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
// 關於雜湊對映的第13，20-23,以及第58行是後加的，進行優化，已經計算過的對於某組n和st的函式generate不在重複進行
class Solution {
public:
    unordered_map<double,vector<TreeNode*>> m;
    vector<TreeNode*> generateTrees(int n) {
        return generate(n,0);
    }
    vector<TreeNode*> generate(int n, int st){
        vector<TreeNode*> res;
        if(n == 0)return res;
        double suanz = st;
        while(suanz >= 1)suanz = suanz/10;
        suanz += n;
        if(m.count(suanz))return m[suanz];
        for(int k = 0; k < n; k ++){
            vector<TreeNode*> l = generate(k,st);
            vector<TreeNode*> r = generate(n - k - 1, st + k + 1);
            if(l.empty() && r.empty()){                
                TreeNode *n = new TreeNode(st + k + 1);
                res.push_back(n);
                return res;
            }
            else if(l.empty() && !r.empty()){
                for(int i = 0; i < r.size(); i ++)
                {
                    TreeNode *n = new TreeNode(st + k + 1);
                    n -> right = r[i];
                    res.push_back(n);
                }
            }
            else if(r.empty() && !l.empty()){
                for(int i = 0; i < l.size(); i ++)
                {
                    TreeNode *n = new TreeNode(st + k + 1);
                    n -> left = l[i];
                    res.push_back(n);
                }
            }
            else{
                for(int i = 0; i < l.size(); i ++)
                    for(int j = 0; j < r.size(); j ++){
                        TreeNode *n = new TreeNode(st + k + 1);
                        n -> left = l[i];
                        n -> right = r[j];
                        res.push_back(n);
                    }
            }            
        }
        m[suanz] = res;
        return res;
    }
};