Problem Description:

Given an integer n, generate all structurally unique BST‘s (binary search trees) that store values 1 ... n.

給定一個整數n，生成所有不同的二叉搜索樹，其節點存儲所有從1到n的值。

此題是96題的follow up，96題采用動態規劃順利接出來了，但是看到這個題時沒有想到如何利用96題的動態規劃的思路（沒有想到clone的方法），碰壁了幾次。

想到過按順序插入值到二叉樹中，但是這樣會出現重復，例如n=3，按2，1，3和按2，3，1插入順序會得到相同的結果，且重復問題難以解決。

可行的解法有遞歸的解法和動態規劃（參考了huahuajiang的的博客https://zxi.mytechroad.com/blog/uncategorized/leetcode-95-unique-binary-search-trees-ii/）。

def gen(s, e):
  return [tree(i, l, r) for l in gen(s, i – 1) for r in gen(i + 1, e) for i in range(s, e+1)

時間復雜度O(n^3) 空間復雜度 O(n^3)

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

要註意這個終止條件，if(start > end)，這個僅僅當循環中i=start或i=end時才會發生，且start最多比end大於1。

然後是動態規劃

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

LeetCode 95. Unique Binary Search Trees II