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

 

 我首先注意到1..n是任何BST节点1到n的有序遍历。

所以如果我选择第i个节点作为我的根，左子树将包含元素1到（i-1），右子树将包含元素（i + 1）到n。

我使用递归调用来找回所有可能的左树子树和右树子树，并将它们以各种可能的方式与根结合起来。

 

二叉搜索树关键的性质是根节点的值大于左子树所有节点的值，小于右子树所有节点的值，且左子树和右子树也同样为二叉搜索树。因此在生成所有可行的二叉搜索树的时候，假设当前序列长度为 nn，如果我们枚举根节点的值为 ii，那么根据二叉搜索树的性质我们可以知道左子树的节点值的集合为 [1 \ldots i-1][1…i−1]，右子树的节点值的集合为 [i+1 \ldots n][i+1…n]。而左子树和右子树的生成相较于原问题是一个序列长度缩小的子问题，因此我们可以想到用回溯的方法来解决这道题目。

我们定义 generateTrees(start, end) 函数表示当前值的集合为 [\textit{start},\textit{end}][start,end]，返回序列 [\textit{start},\textit{end}][start,end] 生成的所有可行的二叉搜索树。按照上文的思路，我们考虑枚举 [\textit{start},\textit{end}][start,end] 中的值 ii 为当前二叉搜索树的根，那么序列划分为了 [\textit{start},i-1][start,i−1] 和 [i+1,\textit{end}][i+1,end] 两部分。我们递归调用这两部分，即 generateTrees(start, i - 1) 和 generateTrees(i + 1, end)，获得所有可行的左子树和可行的右子树，那么最后一步我们只要从可行左子树集合中选一棵，再从可行右子树集合中选一棵拼接到根节点上，并将生成的二叉搜索树放入答案数组即可。

递归的入口即为 generateTrees(1, n)，出口为当 \textit{start}>\textit{end}start>end 的时候，当前二叉搜索树为空，返回空节点即可。

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/unique-binary-search-trees-ii/solution/bu-tong-de-er-cha-sou-suo-shu-ii-by-leetcode-solut/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
public:
    vector<TreeNode*> generate(int low, int high) {
        if(low > high) return vector<TreeNode*>{nullptr};
        vector<TreeNode*> res;
        for(int mid = low; mid <= high; ++mid) {
            auto ltree = generate(low,mid-1);
            auto rtree = generate(mid+1,high);
            for(auto lt:ltree){
                for(auto rt:rtree) {
                    res.push_back(new TreeNode(mid,lt,rt));
                }
            }
        }
        return res;
    }
    vector<TreeNode*> generateTrees(int n) {
        return generate(1,n);
    }
};

 

 

 

class Solution {
    public List<TreeNode> generateTrees(int n) {
        if (n<1) return new ArrayList<TreeNode>();
        return gen(1,n);
    }
    private List<TreeNode> gen(int start,int end){
        List<TreeNode> res = new ArrayList<TreeNode>();
        if(start>end){ //越界
            res.add(null);
            return res;
        }
        if(start==end){ //只有一个点 gen(2,2)
            res.add(new TreeNode(start));
            return res;
        }
        List<TreeNode> left,right;
        for(int i = start;i<=end;i++){
            left = gen(start,i-1);
            right = gen(i+1,end);
            for(TreeNode l :left){
                for(TreeNode r:right){
                    TreeNode root = new TreeNode(i);
                    root.left=l;
                    root.right=r;
                    res.add(root);
                }                
            }         
        }
         return res;
    }
}