I

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的count陣列，count[i]表示數0-i一共能產生多少個不同的BST。

這裡我們要深刻理解BST的一個性質，即BST的任意子樹依然是個BST

顯然的，我們可以發現：

count[0] = 1 空樹

count[1] = 1 只有1節點的樹

在觀察count[2]，我們發現可以這樣計算count[2]：

選擇1做根節點， 由於BST的性質，其左子樹只能是空樹，只有count[0]種可能，右子樹是由節點2組成的樹，一共有count[1]種可能。

選擇2做根節點，同理可得左子樹有count[1]種，右子樹有count[0]種。

因此count[2] = count[0] * count[1] + count[1] * count[0]

通過這個分析，我們可以發現其實判斷有多少unique BST就是讓每個樹做根節點一次，計算他得左子樹數目和右子樹數目，然後相乘即可。

因此其Count[i] = ∑ Count[0...k] * [ k+1....i]

public int numTrees(int n) {
        int[] count = new int[n + 1];
        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 - 1 - j];
            }
        
        return count[n];
    }
 

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

II 的思路和I類似，用同樣的遞迴思路來做。

public List<TreeNode> generateTrees(int n) {
        return generateTrees(1, n);
    }
    
    private List<TreeNode> generateTrees(int start, int end) {
        List<TreeNode> list = new ArrayList<TreeNode>();
        if (start > end) {
            list.add(null);
            return list;
        }
        
        for (int i = start; i <= end; i++) {
            List<TreeNode> lefts = generateTrees(start, i - 1);
            List<TreeNode> rights = generateTrees(i + 1, end);
            for (TreeNode left: lefts) {
                for (TreeNode right: rights) {
                    TreeNode root = new TreeNode(i);
                    root.left = left;
                    root.right = right;
                    list.add(root);
                }
            }
        }
        return list;
    }