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

思路

记f_n为1至n组成的BST的集合。对该BST，根的值有n种情况。对每一个根值i，左树为1至i-1，即问题f_i-1。右树为i+1至n，即问题f_n-i，但每个节点要+i。即

f_n = ∑ f_i-1 * f_n-i (i=1...n)

注： 此处答案要求是一个List，所以*不代表数学的乘积而是将左右树做交叉结合

代码

class Solution {
    public List<TreeNode> generateTrees(int n) {
        List<TreeNode>[] dp = new List[n + 1];
        dp[0] = new ArrayList<>();
        if(n == 0) return dp[0];
        dp[0].add(null);
        
        for(int i = 1; i <= n; i++){
            dp[i] = new ArrayList<>();
            for(int j = 1; j <= i; j++){
                int left = j - 1, right = i - j;
                for(TreeNode leftTree : dp[left])
                    for(TreeNode rightTree : dp[right]){
                        TreeNode root = new TreeNode(j);
                        root.left = clone(leftTree, 0);
                        root.right = clone(rightTree, j);
                        dp[i].add(root);
                    }
            }
        }
        return dp[n];
    }
    
    private TreeNode clone(TreeNode x, int offset){
        if(x == null)
            return null;
        TreeNode result = new TreeNode(x.val + offset);
        result.left = clone(x.left, offset);
        result.right = clone(x.right, offset);
        return result;
    }
}

复杂度（大致分析）

设问题n对应的List长度为l_n，由于每次都从1到n开始填表，则问题n的时间复杂度T_n大致为

T_n = 1*l₁ + 2*l₂ + ...+ n*l_n　　 (1)

其中乘以n的原因是：l_n中的每一颗树都是通过克隆子问题的树形成的。对于一个n个节点的树，克隆的时间为O（n）。

对于每一个l_n，考虑到其左右子树的不同大小，又有

l_n = ∑ l_j-1 * l_n-j (j=1...n) 　　(2)

即l₂ = l₀*l₁ + l₁*l₀, l₃ = l₀*l₂ + l₁*l₁ + l₂*l₀,...

n	0	1	2	3	4	5	6	...
ln	1	1	2	5	14	42	...	...

这是一个卡塔兰数（Catalan Number),我们只要知道其结果即可。结果是l_n = (2n)!/((n+1)!(n)!)。

 

这个链接声称卡塔兰数的和满足

SN≤20⋅4N9eπ−−√N3/2.

SN≤20⋅4N9eπ−−√N3/2.

我们的和里还有一个因子n（式1），大致可以确定T_n大概为O(4ⁿ/n^k)的样子吧，至于k是几不会算（据上式，起码有k<3/2...）……

实际上，卡塔兰数的渐进表示大致为

与上述估算的T_n大致相同（最大的差别在于那个clone所耗费的因子n），也就是说dp算法本身比穷举法的时间复杂度差一点，拖了一点后腿……

不过这个问题用穷举法确实没想到intuitive的算法，backtracking的话估计浪费更严重，dp应该算是比较简洁又复杂度还可以的算法……