LeetCode动态规划篇：96.不同的二叉搜索树

一、题目

链接：https://leetcode-cn.com/problems/unique-binary-search-trees/

给定一个整数 n，求以 1 ... n 为节点组成的二叉搜索树有多少种？

示例:

输入: 3

输出: 5

解释:给定 n = 3, 一共有 5 种不同结构的二叉搜索树:

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

二、题解

2.1 动态规划

根据题意，我们需要寻找从 1 到 n 为节点的二叉搜索树的个数，所以我们先回忆下二叉搜索树的定义。

二叉查找树(Binary Search Tree)，又称二叉搜索树、二叉排序树 ，它或者是一棵空树，或者是具有下列性质的二叉树：

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉排序树。

当我们了解了二叉搜索树的定义后，我们就知道该以什么样的规则来构建一颗二叉搜索树。给定一个整数 n，可以根据数字的序列构建一棵二叉搜索树。首选，我们从 1 到 n，依次遍历每个数字 i，将 i 作为根节点，1～(i-1) 序列作为左子树，(i+1)～ n 序列作为右子树，之后对于左子树和右子树，我们可以根据同样的方法进行构建，这样递归的概念就从中诞生了。因为依次遍历的根节点各不相同，这样就保证了每棵二叉搜索树都是唯一的。

上面提到了递归，但是大家都知道递归很耗时，所以当我们可以使用动态规划的思想将问题分解成规模较小的子问题后，可以存储并复用子问题的解，而不是递归的调用这些子问题，接下来我们就看看如何用动态规划进行求解吧。

• 定义数组元素的含义

• 定义 f(i) 是以 i 为根节点的二叉搜索树的个数；
• 定义 G(n) 为从 1 到 n 的二叉搜索树个数，所以 G[i] 为从 1 到 i 的二叉搜索树个数
• 所以 G(n) 就是最后我们所求的解，G(n) = f(1) + f(2) + f(3) + f(4) + ... + f(n)

• 找出数组之间的递推表达式

• 当我们以 i 为根节点时，[0,i-1] 为左节点，[i+1,n] 为右节点，之后再对 [0,i-1] 和 [i+1,n] 递归求解；
• 从上面的分析我们可以看出，f(i) 就是其左子树和右子树的子问题解的乘积，所以 f(i)=G(i−1)∗G(n−i)
• 由上述公式，可推出 G(n)=G(0)∗G(n−1)+G(1)∗(n−2)+...+G(n−1)∗G(0)

• 找出初始值

• G[0]=1，当树是一颗空树时，我们也认为是一颗二叉搜索树；
• G[1]=1，当整颗树只有一个节点时，其二叉搜索树只有一种；
• G[2]=2，当整棵树只有两个节点时，其二叉搜索树只有一种；

虽然我们很容易知道 G[2] 的值，这里我们还是带入递推表达式的公式理解一下，这里我们用 dp 表示 G，dp[2] = f(1)+f(2)= dp[0] * dp[1] (1为根的情况) + dp[1] * dp[0] (2为根的情况)。

时间复杂度：O(n^2)

空间复杂度：O(n)

Python：

class Solution:
    def numTrees(self, n: int) -> int:
        dp=[0]*(n+1)
        dp[0]=1
        dp[1]=1

        for i in range(2,n+1):
            for j in range(1,i+1):
                dp[i]+=dp[j-1]*dp[i-j] 
        return dp

Go:

func numTrees(n int) int {
    dp:=make([]int,n+1)
    dp[0],dp[1]=1,1
    for i:=2;i<=n;i++{
        for j:=1;j<=i;j++{
            dp[i]+=dp[j-1]*dp[i-j]
        }
    }
    return dp[n]
}

2.2 数学

如果想要优化时间复杂度和空间复杂度，可以通过卡特兰数。卡特兰数有一个递推关系，但是对于卡特兰数的证明我也不会，大家可以自行 Google 或者百度搜索了解一下吧。

递推关系如下：

时间复杂度：O(n)

空间复杂度：O(1)

Python:

class Solution:
    def numTrees(self, n: int) -> int:
        C=1
        for i in range(n):
            C=2*(2*i+1)*C/(i+2)
        return int(C)

Go:

func numTrees(n int) int {
    C:=1
    for i:=0;i<n;i++{
        C=2*(2*i+1)*C/(i+2)
    }
    return C
}