leetcode笔记——95不同的二叉搜索树Ⅱ

题目：

给定一个整数 n，生成所有由 1 ... n 为节点所组成的二叉搜索树。

示例:

输入: 3
输出:
[
  [1,null,3,2],
  [3,2,null,1],
  [3,1,null,null,2],
  [2,1,3],
  [1,null,2,null,3]
]
解释:
以上的输出对应以下 5 种不同结构的二叉搜索树：

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

思路：在网上找的大神的代码。原文链接：https://blog.youkuaiyun.com/onedeveloper/article/details/80169460。

参考了文章https://blog.youkuaiyun.com/happyaaaaaaaaaaa/article/details/51635367

今天这个题是真的理解不了。。。。递归和二叉树，还有这个两层的循环不懂。。。先把其他大神的思路放在这里。看不懂

1. 每一次都在一个范围内随机选取一个结点作为根。
2. 每选取一个结点作为根，就把树切分成左右两个子树，直至该结点左右子树为空。

大致思路如上，可以看出这也是一个可以划分成子问题求解的题目，所以考点是动态规划。
但具体对于本题来说，采取的是自底向上的求解过程。
1. 选出根结点后应该先分别求解该根的左右子树集合，也就是根的左子树有若干种，它们组成左子树集合，根的右子树有若干种，它们组成右子树集合。
2. 然后将左右子树相互配对，每一个左子树都与所有右子树匹配，每一个右子树都与所有的左子树匹配。然后将两个子树插在根结点上。
3. 最后，把根结点放入链表中。
（原文：https://blog.youkuaiyun.com/ChilseaSai/article/details/50083201）

 

代码：

这个代码我有点看不懂。。。。。。也是用了递归的思想

class Solution {
    public List<TreeNode> generateTrees(int n) {
        if (n < 1) return new ArrayList<>();
        //利用一个辅助数组保存中间的值，避免重复求取，但是也会导致有些子树的结点是公共的
        List[][] dp = new List[n + 2][n + 2];
        return generateTrees(1, n,dp);
    }
    private List<TreeNode> generateTrees(int start, int end, List[][] dp) {
        List<TreeNode> res = new ArrayList<>();
        if (end < start) {
            res.add(null);
            return res;
        }
        for (int i = start; i <= end; i++) {
            List<TreeNode> list1 = dp[start][i - 1];
            if (list1 == null) {
                //递归，并将结果保存下来
                list1 = generateTrees(start, i - 1, dp);
                dp[start][i - 1] = list1;
            } //（start,i-1）为左子树，遍历不同的左子树组合
            for (TreeNode left : list1) {
                List<TreeNode> list2 = dp[i + 1][end];//当 i = n 时，就需要求 dp[n+1][end] 的值
                if (list2 == null) {
                    //递归，并将结果保存下来
                    list2 = generateTrees(i + 1, end, dp);
                    dp[i + 1][end] = list2;
                } //（i+1,end）为右子树，遍历不同的右子树组合
                for (TreeNode right : list2) {
                    TreeNode root = new TreeNode(i);
                    root.left = left;
                    root.right = right;
                    res.add(root);
                }
            }
        }
        return res;
    }

}

以下的代码是另外的一种思路：

我能稍微理解下面这个的思路，就是使用递归调用，确定一个根节点，然后在递归求解出相应的左子树和右子树的各种情况，接着将左右子树一一配对。但是这个题是怎么和动态规划有关系的？主要还是用到递归的思想

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