LeetCode - Unique Binary Search Trees

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

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

http://oj.leetcode.com/problems/unique-binary-search-trees/

Solution:

Consider from 0. If n = 0, res = 1; n = 1, res = 1; n = 2, res = 2; n = 3, res = 5. Use dp method.

Assume there is a count[] that count[n] means the number of unique BSTs that {1, ..., n} can create.

count[2] = num of BST with root 1 + num of BST with root 2, which is count[0] * count[1] + count[1] * count[0].

count[3] = num of BST with root 1 + num of BST with root 2 + num of BST with root 3, which is count[0] * count[2] + count[1] * count[1] + count[2] * count[0].

Obviously we find that count[j] = sum(count[0, ..., i-1] * count[i-1, .., 0]).

Another way if you are familiar with combinatorial mathematics, this is catalan number. http://en.wikipedia.org/wiki/Catalan_number

In that case it is much simpler.

https://github.com/starcroce/leetcode/blob/master/unique_binary_search_trees.cpp

// 4 ms for 14 test cases
// Given n, how many structurally unique BST's (binary search trees) that store values 1...n?
class Solution {
public:
    int numTrees(int n) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        int count[n];
        for(int i = 0; i <= n; i++) {
            count[i] = 0;
        }
        count[0] = 1;
        count[1] = 1;
        for(int i = 2; i <= n; i++) {
            for(int j = 0; j < i; j++) {
                count[i] += count[j] * count[i-j-1];
            }
        }
        return count[n];
    }
};