LeetCode算法系列：95 && 96 Unique Binary Search Trees I && II

题目描述：

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;
    }
};