LeetCode 96. Unique Binary Search Trees

最新推荐文章于 2025-04-04 00:09:22 发布

原创最新推荐文章于 2025-04-04 00:09:22 发布 · 175 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 题解专栏收录该内容

288 篇文章

订阅专栏

本文探讨了如何计算给定整数n时，能构建的不同结构的二叉搜索树的数量。通过动态规划方法，详细解释了从2节点到更多节点时的计算逻辑，并提供了完整的C++代码实现。

Given n, how many structurally unique BST's (binary search trees) that store values 1...n?

For example,
Given n = 3, there are a total of 5 unique BST's.

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

Use dp[i] to memory i nodes BST.

dp[0] = 1; dp[1] = 1

Things get complicate from 2 nodes:

2 nodes : 0, 1.

If we take 0 as the root. Then, there is 1 node left, one 1 BST.

If we take 0 as the root, then, there is 1 node left, one 1 BST ---- thus, there are 2 BSTs in total.

3 nodes: 0, 1, 2

If we take 0 as the root, there are 2 nodes left, thus the BSTs == dp[2];

If we take 1 as the root, there are 2 nodes left, one on the left, one on the right, thus, all the possibilities: dp[1] * dp[1] (Notice, here is not Plus)

If we take 2 as the root, there are 2 nodes left, two both are on the left, thus BSTs = dp[2].. --- Thus the sum is dp[2] + dp[1] * dp[1] + dp[2]

4 nodes: 0, 1, 2, 3

If we take 0 as the root, there are 3 nodes left, thus the BSTs = dp[0]*dp[3]

If we take 1 as the root, there are 3 nodes left, one on the left, two on the right, thus, BSTs = dp[1] * dp[2];

If we take 2 as the root, there are 3 nodes left, two on the left, one on the right, thus BSTs = dp[2] * dp[1];

If we take 3 as the root, there are 3 nodes left, three on the left, thus, BSTs = dp[3]*dp[0] ----> dp[0]*dp[3] + dp[1][2] + dp[2]*dp[1] + dp[3]*dp[0]

.....so on and so forth.....

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