【Leetcode】96. 不同的二叉搜索树

题目描述

// 96. 不同的二叉搜索树

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

题解

// 动态规划
// "有多少种？"这种问题第一时间想到动态规划。如何对BST结构使用呢？
//
// 假设给定的整数n为6，那我们就有1 2 3 4 5 6 这6个节点，每一个节点都有可能
// 成为根结点，如果1为根结点，则2 3 4 5 6必在右子树，如果3为根结点，则1 2在
// 左子树，4 5 6在右子树，以此类推。
// 设f(i)是根结点固定为i时，能组成BST的数量。我们题目要求的答案就是f(n)，
// 如果n=0时，那f(n=0)=1，只有一种空结点情况。如果n=1，那f(n=1)=1，只有一种
// 单个结点的情况。如果n=2，那显而易见f(n=2)=2，俩结点各为根时有两种情况。
// 
// 如果n=3呢？那我们得考虑所有结点作为根结点的情况，n=3，有1 2 3这3个结点，
// 若1为根结点，左子树有f(0)种情况，右子树有f(2)种情况，总共有f(0)*f(2)种情况，
// 若2为根结点，左子树有f(1)种情况，右子树有f(1)种情况，总共有f(1)*f(1)种情况，
// 若3为根结点，左子树有f(2)种情况，右子树有f(0)种情况，总共有f(2)*f(0)种情况
// 最后累加起来有f(n=3) = f(0)*f(2) + f(1)*f(1) + f(2)*f(0)。
//
// 如果n=4呢？那我们要求的是f(n=4)，n=4包括1 2 3 4这4个结点，
// 若1为根结点，左子树有f(0)种情况，右子树有f(3)种情况，总共有f(0)*f(3)种情况，
// 若2为根结点，左子树有f(1)种情况，右子树有f(2)种情况，总共有f(1)*f(2)种情况，
// 若3为根结点，左子树有f(2)种情况，右子树有f(1)种情况，总共有f(2)*f(1)种情况，
// 若4为根结点，左子树有f(3)种情况，右子树有f(0)种情况，总共有f(3)*f(0)种情况， 
// 最后累加起来有f(n=4) = f(0)*f(3) + f(1)*f(2) + f(2)*f(1) + f(3)*f(0)。
// 
// 如果有i个结点，求f(i)，n=i，有1 2 3 ... i个结点，
// 若1为根结点，左子树有f(0)种情况，右子树有f(i-1)种情况，总共有f(0)*f(i-1)种情况，
// 若2为根结点，左子树有f(1)种情况，右子树有f(i-2)种情况，总共有f(1)*f(i-2)种情况，
// ...
// 若i为根结点，左子树有f(i-1)种情况，右子树有f(0)种情况，总共有f(i-1)*f(0)种情况，
// 最后累加起来有f(n=i) = f(0)*f(i-1) + f(1)*f(i-2) + ... + f(i-1)*f(0)
// 这里我们找到了规律，可以用一个for循环求出f(i)，即n=i时的BST组合数量，
// for (int j = 0; j < i; j++) { f(i) += f(j) * f(i - 1 - j) }
// 
// 解法：
// 构建dp数组，dp[i]表示f(i)，即n=i时BST的组合数量，则dp[n=0]=1，dp[n=1]=1。
// 我们构建两个for循环，
// 第一个for循环从dp当n=2时遍历到dp末位，即从dp[2]到dp[n]，遍历索引就为i，
// 元素为dp[i]，我们需要动态规划把dp[2],dp[3],...,一直计算到我们需要的dp[n]。
// 当遍历到dp[i]时，第二个for循环计算dp[i]的值，就用我们刚刚的办法：
// for (int j = 0; j < i; j++) { dp[i] += dp[j] * dp[i - 1 - j] }
// 
// 当双循环结束，返回dp[n]即可。
//
// 执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
// 内存消耗：35.1 MB, 在所有 Java 提交中击败了77.05%的用户
class Solution {
    public int numTrees(int n) {
		int[] dp = new int[n + 1];
		dp[0] = 1;
		dp[1] = 1;
		for (int i = 2; i < n + 1; i++) {
			for (int j = 0; j < i; j++) {
				dp[i] += dp[j] * dp[i - 1 - j];
			}
		}
		return dp[n];
    }
}