leetcode 96|95. Unique Binary Search Trees 1|2

96. Unique Binary Search Trees

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

For example,
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

给定一个数n，求1到n这些数可以构成多少棵二叉搜索树。

我们可以使用1......n中的每一个数i作为根节点，

自然1......(i-1)必然位于树的左子树中，(i+1).....n位于树的右子树中。

然后可以递归来构建左右子树，由于根节点是唯一的，所以可以保证构建的二叉树都是唯一的。

   
way-1:递归 TLE…

way-2:非递归，动态规划  G[i] 代表有 1....i个数作为节点构成二叉搜索树的种类

---

class Solution {
public:
    int numTrees(int n) 
    {
        int G[n+1] = {};
        G[0] = 1;
        G[1] = 1;
       
        for (int i = 2; i <= n; i++)
        {
            for(int j = 0; j < i; j++)
            {
                G[i] += G[j] * G[i-j-1];
            }
        }
        return G[n];    
    }
};

95. Unique Binary Search Trees II

Given an integer 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

---

由于1~n是升序列，因此建起来的树天然就是BST。

分治的思想，依次选择根节点，对左右子序列再分别建树。

由于左右子序列建树的结果也可能不止一种，需要考虑所有搭配情况。

vector<TreeNode *> left代表所有valid左子树。
vector<TreeNode *> right代表所有valid右子树。 

/**
 * 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*> guocheng(int begin, int end)
    {
        vector<TreeNode*> ret;
        if (begin > end)
        {
            ret.push_back(NULL);
        }
        else if (begin == end)
        {
            ret.push_back( new TreeNode(begin) );
        }
        else
        {
            for(int i = begin;i <= end;i++)
            {
                vector<TreeNode*> left = guocheng(begin, i-1);
                vector<TreeNode*> right = guocheng(i+1, end);
                for(int j = 0; j < left.size(); j++)
                {
                    for(int k = 0; k < right.size(); k++)
                    {
                        TreeNode *rr = new TreeNode(i);
                        rr->left = left[j];
                        rr->right = right[k];
                        ret.push_back(rr);
                    }
                }
            }
        }
        return ret;
    }
  
    vector<TreeNode*> generateTrees(int n) 
    { 
        if (n == 0)
        {
            return vector<TreeNode*>();              
        }
        return guocheng(1, n);
    }
};