LeetCode 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

思路：这是Unique Binary Search Trees的变形，基本思路是一样的，这里用递归做的时候，先假设调用两边的时候，返回的是List< TreeNode >，这样得到的是左边和右边子树的全部情况，因此在向上一层返回的时候，应该要遍历list里的所有左子树和右子树，然后都用当前的root添加一遍，最后一层层向上返回。

代码：

public List<TreeNode> generateTrees(int n) {
        List<TreeNode> result = new ArrayList<>();
        if (n == 0) return result;
        return helper(1, n);
    }
    public List<TreeNode> helper(int start, int end) {
        List<TreeNode> result = new ArrayList<>();
        if (start > end) {
            result.add(null);
            return result;
        }
        for (int i = start; i <= end; i++) {
            List<TreeNode> left = helper(start, i - 1);
            List<TreeNode> right = helper(i + 1, end);
            for (TreeNode leftNode : left) {
                for (TreeNode rightNode : right) {
                    TreeNode root = new TreeNode(i);
                    root.left = leftNode;
                    root.right = rightNode;
                    result.add(root);
                }
            }
        }
        return result;
    }

解法二：用dp，因为recursion的话，每次bottom up的时候都会重新计算一遍，然而用dp的方法，每次都可以直接利用之前算好的，所以可以避免重复计算。

class Solution {
     public List<TreeNode> generateTrees(int n) {
        if(n < 1)
            return new ArrayList<>();
        //注意这里，dp的长度为n+2是因为recursion里的i-1，i+1,而i的范围是1~n,因此，dp的范围要比n多两个，0~n+1，所以dp需要n+2的长度！
        List<TreeNode>[][] dp = new List[n+2][n+2];
        return helper(1, n, dp);
    }

    public List<TreeNode> helper(int start, int end, List[][] dp){
        //这里的判断语句就是用来调用已经算过的结果，避免重复运算的。
        if(dp[start][end] != null)
            return dp[start][end];
        List<TreeNode> list = new ArrayList<>();
        if(start > end){
            list.add(null);
        }
        else if(start==end){
            list.add(new TreeNode(start));
        }
        else{
             for(int i = start; i <= end; i++){
                List<TreeNode> left = helper(start, i-1, dp);
                List<TreeNode> right = helper(i+1, end, dp);
                for(TreeNode l : left){
                    for(TreeNode r : right){
                        TreeNode node = new TreeNode(i);
                        node.left = l;
                        node.right = r;
                        list.add(node);
                    }
                }
            }
        }
        dp[start][end] = list;
        return list;
    }

}