动态规划专训8——背包问题

动态规划题目中，常出现背包的相关问题，这里单独挑出来训练

A.01背包

1.01背包模板题

【模板】01背包_牛客题霸_牛客网 (nowcoder.com)

你有一个背包，最多能容纳的体积是V。

现在有n个物品，第i个物品的体积为𝑣𝑖vi ,价值为𝑤𝑖wi。

（1）求这个背包至多能装多大价值的物品？

（2）若背包恰好装满，求至多能装多大价值的物品？

第一问

1.状态表示：用dp[ i ][ j ]表示选到第 i 个物品，体积不超过 j ，物品的最大价值

2.状态转移方程：dp[ i ][ j ] = max(dp[ i - 1 ][ j ], dp[ i - 1 ][ j - v[ i ] ] + w[ i ] )

3.初始化：无需初始化

4.填表顺序：从上往下每一行

5.返回值：dp[ n ][ V ]

注意：由于 j - v[ i ] 可能小于0，所以需要提前特判

第二问

1.状态表示：用dp[ i ][ j ]表示选到第 i 个物品，体积恰好 j ，物品的最大价值

2.状态转移方程：dp[ i ][ j ] = max(dp[ i - 1 ][ j ], dp[ i - 1 ][ j - v[ i ] ] + w[ i ] )

3.初始化：根据题目初始化（见注意）

4.填表顺序：从上往下每一行

5.返回值：dp[ n ][ V ]

注意：由于dp状态表示地特殊性，可能存在无法使状态存在的情况，所以我们规定用 - 1 来表示状态不存在，于是在 j >= 1使，dp[ 0 ][ j ] = -1，在打印值时，也需要提前特判

#include<iostream>
#include<vector>
#include<string.h>

using namespace std;

const int N = 1010;
int n, V, v[N], w[N];

int dp[N][N];

int main()
{
    cin >> n >> V;
    for(int i = 1; i <= n; ++i)
        cin >> v[i] >> w[i];
    
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= V; ++j)
        {
            dp[i][j] = dp[i - 1][j];
            if(j >= v[i]) dp[i][j] = max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
        }

    cout << dp[n][V] << endl;

    memset(dp, 0, sizeof dp);
    
    for(int j = 1; j <= V; ++j) dp[0][j] = -1;
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= V; ++j)
        {
            dp[i][j] = dp[i - 1][j];
            if(j >= v[i] && dp[i - 1][j - v[i]] != -1) dp[i][j] = max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
        }

    cout << (dp[n][V] == -1 ? 0 : dp[n][V]) << endl;
    return 0;
}

这是二维ac代码

#include<iostream>
#include<vector>
#include<string.h>

using namespace std;

const int N = 1010;
int n, V, v[N], w[N];

int dp[N];

int main()
{
    cin >> n >> V;
    for(int i = 1; i <= n; ++i)
        cin >> v[i] >> w[i];
    
    for(int i = 1; i <= n; ++i)
        for(int j = V; j >= v[i]; --j)
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]);

    cout << dp[V] << endl;

    memset(dp, 0, sizeof dp);
    
    for(int j = 1; j <= V; ++j) dp[j] = -1;
    for(int i = 1; i <= n; ++i)
        for(int j = V; j >= v[i]; --j)
            if(dp[j - v[i]] != -1) dp[j] = max(dp[j], dp[j - v[i]] + w[i]);

    cout << (dp[V] == -1 ? 0 : dp[V]) << endl;
    return 0;
}

这是一维ac代码

2.分割等和子集

416. 分割等和子集

给你一个 只包含正整数 的非空数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等

1.状态表示：用dp[ i ][ j ]表示选到第 i 个数，和恰好 j 情况是否存在

2.状态转移方程：dp[ i ][ j ] = dp[ i - 1 ][ j ] || ( j >= nums[ i - 1 ] && dp[ i - 1 ][ j - nums[ i - 1 ] ] )

3.初始化：根据题目初始化（见注意）

4.填表顺序：从上往下每一行

5.返回值：dp[ n ][ k ]

注意：将题目转换为找出数组和一半的子序列，k = sum / 2，这样当 j = 0时dp[ i ][ 0 ] = true，且如果sum是奇数也可以直接返回false

class Solution {
public:
    bool canPartition(vector<int>& nums) 
    {
        int n = nums.size();
        int sum = 0;
        for(int e : nums) sum += e;
        if(sum % 2) return false;
        int k = sum / 2;
        vector<vector<bool>> dp(n + 1, vector<bool>(k + 1));
        for(int i = 0; i <= n; ++i) dp[i][0] = true;
        for(int i = 1; i <= n; ++i)
            for(int j = 1; j <= k; ++j)
                dp[i][j] = dp[i - 1][j] || (j >= nums[i - 1]  && dp[i - 1][j - nums[i - 1]]);

        return dp[n][k]; 
    }
};

这是二维ac代码

class Solution {
public:
    bool canPartition(vector<int>& nums) 
    {
        int n = nums.size();
        int sum = 0;
        for(int e : nums) sum += e;
        if(sum % 2) return false;
        int k = sum / 2;
        vector<bool> dp(k + 1);
        dp[0] = true;
        for(int i = 1; i <= n; ++i)
            for(int j = k; j >= nums[i - 1]; --j)
                dp[j] = dp[j] || dp[j - nums[i - 1]];

        return dp[k]; 
    }
};

这是一维ac代码

3.目标和

494. 目标和

给你一个非负整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：

例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。

返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目

转换

设正数和为a，负数和绝对值为b，则 a + b = sum, a - b = target，于是有a = (sum + target) / 2，所以只要找出和为a的子序列即可，注意当(sum + target) 是奇数以及 a 小于0时直接返回0

1.状态表示：用dp[ i ][ j ]表示选到第 i 个数，和恰好 j 情况数目

2.状态转移方程：dp[ i ][ j ] = dp[ i - 1 ][ j ] + dp[ i - 1 ][ j - nums[ i - 1 ] ]

3.初始化：dp[ 0 ][ 0 ] = 1;

4.填表顺序：从上往下每一行

5.返回值：dp[ n ][ k ]

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) 
    {
        int sum = 0, n = nums.size();
        for(int e : nums) sum += e;
        int k = (target + sum) / 2;
        if(k < 0 || (sum + target) % 2) return false;

        vector<vector<int>> dp(n + 1, vector<int>(k + 1));
        dp[0][0] = 1;
        for(int i = 1; i <= n; ++i)
            for(int j = 0; j <= k; ++j)
            {
                dp[i][j] = dp[i - 1][j];
                if(j >= nums[i - 1]) dp[i][j] += dp[i - 1][j - nums[i - 1]];
            }

        return dp[n][k];
    }
};

这是二维ac代码

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) 
    {
        int sum = 0, n = nums.size();
        for(int e : nums) sum += e;
        int k = (target + sum) / 2;
        if(k < 0 || (sum + target) % 2) return false;

        vector<int> dp(k + 1);
        dp[0] = 1;
        for(int i = 1; i <= n; ++i)
            for(int j = k; j >= nums[i - 1]; --j)
                dp[j] += dp[j - nums[i - 1]];

        return dp[k];
    }
};

这是一维ac代码

4.最后一块石头的重量

1049. 最后一块石头的重量 II

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

转换，从数组中挑选一堆石头使其接近 sum / 2，再使剩下的石头重量与其做差即可

于是我们要找到重量小于 sum / 2 的最大重量

1.状态表示：用dp[ i ][ j ]表示选到第 i 个数，重量不大于 j 的最大重量

2.状态转移方程：dp[ i ][ j ] = max(dp[ i - 1 ][ j ], dp[ i - 1 ][ j - nums[ i - 1 ] ] + nums[ i - 1 ] )

3.初始化：无需初始化

4.填表顺序：从上往下每一行

5.返回值：dp[ n ][ k ]

class Solution {
public:
    int lastStoneWeightII(vector<int>& nums) 
    {
        int sum = 0, n = nums.size();
        for(int e : nums) sum += e;
        int k = sum / 2;
        vector<vector<int>> dp(n + 1, vector<int>(k + 1));
        for(int i = 1; i <= n; ++i)
            for(int j = 1; j <= k; ++j)
            {
                dp[i][j] = dp[i - 1][j];
                if(j >= nums[i - 1]) 
                    dp[i][j] = max(dp[i][j], dp[i - 1][j - nums[i - 1]] + nums[i - 1]);
            }

        return sum - dp[n][k] * 2;
    }
};

这是二维ac代码

class Solution {
public:
    int lastStoneWeightII(vector<int>& nums) 
    {
        int sum = 0, n = nums.size();
        for(int e : nums) sum += e;
        int k = sum / 2;
        vector<int> dp(k + 1);
        for(int i = 1; i <= n; ++i)
            for(int j = k; j >= nums[i - 1]; --j)
                dp[j] = max(dp[j], dp[j - nums[i - 1]] + nums[i - 1]);

        return sum - dp[k] * 2;
    }
};

这是一维ac代码

B.完全背包

5.完全背包模板题

【模板】完全背包_牛客题霸_牛客网 (nowcoder.com)

你有一个背包，最多能容纳的体积是V。

现在有n种物品，每种物品有任意多个，第i种物品的体积为𝑣𝑖vi ,价值为𝑤𝑖wi。

（1）求这个背包至多能装多大价值的物品？

（2）若背包恰好装满，求至多能装多大价值的物品？

第一问

1.状态表示：用dp[ i ][ j ]表示选到第 i 个物品，体积不超过 j ，物品的最大价值

2.状态转移方程：dp[ i ][ j ] = max(dp[ i - 1 ][ j ], dp[ i ][ j - v[ i ] ] + w[ i ] )

3.初始化：无需初始化

4.填表顺序：从上往下每一行

5.返回值：dp[ n ][ V ]

第二问

1.状态表示：用dp[ i ][ j ]表示选到第 i 个物品，体积恰好 j ，物品的最大价值

2.状态转移方程：dp[ i ][ j ] = max(dp[ i - 1 ][ j ], dp[ i ][ j - v[ i ] ] + w[ i ] )

3.初始化：根据题目初始化（见注意）

4.填表顺序：从上往下每一行

5.返回值：dp[ n ][ V ]

#include<iostream>
#include<vector>
#include<string.h>

using namespace std;

const int N = 1010;
int n, V, v[N], w[N];

int dp[N][N];

int main()
{
    cin >> n >> V;
    for(int i = 1; i <= n; ++i)
        cin >> v[i] >> w[i];
    
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= V; ++j)
        {
            dp[i][j] = dp[i - 1][j];
            if(j >= v[i]) dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);
        }
    cout << dp[n][V] << endl;

    memset(dp, 0, sizeof dp);

    for(int j = 1; j <= V; ++j) dp[0][j] = -1;
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= V; ++j)
        {
            dp[i][j] = dp[i - 1][j];
            if(j >= v[i] && dp[i][j - v[i]] != -1) dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);
        }
    cout << (dp[n][V] == -1 ? 0 : dp[n][V]) << endl;

    return 0;
}

这是二维ac代码

#include<iostream>
#include<vector>
#include<string.h>

using namespace std;

const int N = 1010;
int n, V, v[N], w[N];

int dp[N];

int main()
{
    cin >> n >> V;
    for(int i = 1; i <= n; ++i)
        cin >> v[i] >> w[i];
    
    for(int i = 1; i <= n; ++i)
        for(int j = v[i]; j <= V; ++j)
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
    cout << dp[V] << endl;

    memset(dp, 0, sizeof dp);

    for(int j = 1; j <= V; ++j) dp[j] = -1;
    for(int i = 1; i <= n; ++i)
        for(int j = v[i]; j <= V; ++j)
            if(dp[j - v[i]] != -1) dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
    cout << (dp[V] == -1 ? 0 : dp[V]) << endl;

    return 0;
}

这是一维ac代码

6.零钱兑换

322. 零钱兑换

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的

1.状态表示：用dp[ i ][ j ]表示选到第 i 个硬币，价值恰好等于 j ，最小的数目

2.状态转移方程：dp[ i ][ j ] = min(dp[ i - 1 ][ j ], dp[ i ][ j - coins[ i - 1 ] ] + 1)

3.初始化：dp[ 0 ][ j ] = 0x3f3f3f3f

4.填表顺序：从上往下每一行

5.返回值：dp[ n ][ am ]

注意：由于可能选择方案无法构成 j ，用0x3f3f3f3f来表示该状态不存在，同时在返回值时也需特判

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) 
    {
        const int INF = 0x3f3f3f3f;
        int n = coins.size();
        vector<vector<int>> dp(n + 1, vector<int>(amount + 1));
        for(int j = 1; j <= amount; ++j) dp[0][j] = INF;
        for(int i = 1; i <= n; ++i)
            for(int j = 1; j <= amount; ++j)
            {
                dp[i][j] = dp[i - 1][j];
                if(j >= coins[i - 1]) dp[i][j] = min(dp[i][j], dp[i][j - coins[i - 1]] + 1);
            }
        
        return (dp[n][amount] == INF ? -1 : dp[n][amount]);
    }

这是二维ac代码

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) 
    {
        const int INF = 0x3f3f3f3f;
        int n = coins.size();
        vector<int> dp(amount + 1);
        for(int j = 1; j <= amount; ++j) dp[j] = INF;
        for(int i = 1; i <= n; ++i)
            for(int j = coins[i - 1]; j <= amount; ++j)
                dp[j] = min(dp[j], dp[j - coins[i - 1]] + 1);
        
        return (dp[amount] == INF ? -1 : dp[amount]);
    }
};

这是一维ac代码

7.零钱兑换II

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

假设每一种面额的硬币有无限个。

题目数据保证结果符合 32 位带符号整数。

1.状态表示：用dp[ i ][ j ]表示选到第 i 个硬币，价值恰好等于 j ，组合的总数

2.状态转移方程：dp[ i ][ j ] = dp[ i - 1 ][ j ] + dp[ i ][ j - coins[ i - 1 ] ]

3.初始化：dp[ 0 ][ 0 ] = 1;

4.填表顺序：从上往下每一行

5.返回值：dp[ n ][ am ]

class Solution {
public:
    int change(int amount, vector<int>& coins) 
    {
        int n = coins.size();
        vector<vector<int>> dp(n + 1, vector<int>(amount + 1));
        dp[0][0] = 1;
        for(int i = 1; i <= n; ++i)
            for(int j = 0; j <= amount; ++j)
            {
                dp[i][j] = dp[i - 1][j];
                if(j >= coins[i - 1]) dp[i][j] += dp[i][j - coins[i - 1]];
            }

        return dp[n][amount];
    }
};

这是二维ac代码

class Solution {
public:
    int change(int amount, vector<int>& coins) 
    {
        int n = coins.size();
        vector<int> dp(amount + 1);
        dp[0] = 1;
        for(int i = 1; i <= n; ++i)
            for(int j = coins[i - 1]; j <= amount; ++j)
                dp[j] += dp[j - coins[i - 1]];

        return dp[amount];
    }
};

这是一维ac代码

8.完全平方数

给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。

完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。

1.状态表示：用dp[ i ][ j ]表示选到第 i 个数，价值恰好等于 j ，所需平方数的最小数目

2.状态转移方程：dp[ i ][ j ] = dp[ i - 1 ][ j ] + dp[ i ][ j - i * i ] + 1

3.初始化：dp[ 0 ][ 0 ] = 1;其他全部初始化为0x3f3f3f3f

4.填表顺序：从上往下每一行

5.返回值：dp[ n ][ k ]

注意：由于题目的特殊性，这里的“体积” k = sqrt( n )，而对于状态表示无意义的dp我们用0x3f3f3f3f标识，同时，返回数据时也要特判

class Solution {
public:
    int numSquares(int n) 
    {
        const int INF = 0x3f3f3f3f;
        int k = sqrt(n);
        vector<vector<int>> dp(k + 1, vector<int>(n + 1, INF));
        dp[0][0] = 0;
        for(int i = 1; i <= k; ++i)
            for(int j = 0; j <= n; ++j)
            {
                dp[i][j] = dp[i - 1][j];
                if(j >= i * i) dp[i][j] = min(dp[i][j], dp[i][j - i * i] + 1);
            }

        return dp[k][n] == INF ? 0 : dp[k][n];
    }
};

这是二维ac代码

class Solution {
public:
    int numSquares(int n) 
    {
        const int INF = 0x3f3f3f3f;
        int k = sqrt(n);
        vector<int> dp(n + 1, INF);
        dp[0] = 0;
        for(int i = 1; i <= k; ++i)
            for(int j = i * i; j <= n; ++j)
                dp[j] = min(dp[j], dp[j - i * i] + 1);

        return dp[n] == INF ? 0 : dp[n];
    }
};

这是一维ac代码

C.二维费用的背包问题

9.一和零

474. 一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中最多有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的子集

1.状态表示：用dp[ i ][ j ][ k ]表示选到第 i 个数，0 数目小于 j ，1数目小于 k 的最大字符串数

2.状态转移方程：dp[ i ][ j ][ k ] = max(dp[ i - 1 ][ j ][ k ], dp[ i - 1 ][ j - a ][ k - b ] + 1)

3.初始化：无需初始化

4.填表顺序：从上往下每一行

5.返回值：dp[ len ][ m ][ n ]

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) 
    {
        int len = strs.size();
        vector<vector<vector<int>>> dp(len + 1, vector<vector<int>>(m + 1, vector<int>(n + 1)));
        for(int i = 1; i <= len; ++i)
        {
            string s = strs[i - 1];
            int a = 0, b = 0;
            for(auto e : s)
                if(e == '0') ++a;
                else ++b;
            for(int j = 0; j <= m; ++j)
                for(int k = 0; k <= n; ++k)
                {
                    dp[i][j][k] = dp[i - 1][j][k];
                    if(j >= a && k >= b)
                        dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - a][k - b] + 1);
                }
        }

        return dp[len][m][n];
    }
};

这是二维ac代码

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) 
    {
        int len = strs.size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        for(int i = 1; i <= len; ++i)
        {
            string s = strs[i - 1];
            int a = 0, b = 0;
            for(auto e : s)
                if(e == '0') ++a;
                else ++b;
            for(int j = m; j >= a; --j)
                for(int k = n; k >= b; --k)
                    dp[j][k] = max(dp[j][k], dp[j - a][k - b] + 1);
        }

        return dp[m][n];
    }
};

这是一维ac代码

10.盈利计划

集团里有 n 名员工，他们可以完成各种各样的工作创造利润。

第 i 种工作会产生 profit[i] 的利润，它要求 group[i] 名成员共同参与。如果成员参与了其中一项工作，就不能参与另一项工作。

工作的任何至少产生 minProfit 利润的子集称为 盈利计划 。并且工作的成员总数最多为 n 。

有多少种计划可以选择？因为答案很大，所以 返回结果模 10^9 + 7 的值

1.状态表示：用dp[ i ][ j ][ k ]表示选到第 i 个计划，员工数目不大于 j ，利润不小于 k

2.状态转移方程：dp[ i ][ j ][ k ] = (dp[ i - 1 ][ j ][ k ] + dp[ i - 1 ][ j - g[ i - 1 ] ] [max(0, k - p[ i - 1 ] ) ] ) % a;

3.初始化：dp[ 0 ][ j ][ 0 ] = 1

4.填表顺序：从上往下每一行

5.返回值：dp[ m ][ n ][ mP ]

class Solution {
public:
    int profitableSchemes(int n, int mP, vector<int>& g, vector<int>& p) 
    {
        const int a = 1e9 + 7;
        int m = g.size();
        vector<vector<vector<int>>> dp(m + 1, vector<vector<int>>(n + 1, vector<int>(mP + 1)));
        for(int j = 0; j <= n; ++j)
            dp[0][j][0] =1;
        for(int i = 1; i <= m; ++i)
            for(int j = 0; j <= n; ++j)
                for(int k = 0; k <= mP; ++k)
                {
                    dp[i][j][k] = dp[i - 1][j][k];
                    if(j >= g[i - 1])
                        dp[i][j][k] = (dp[i][j][k] + dp[i - 1][j - g[i - 1]][max(0, k - p[i - 1])]) % a;
                }

        return dp[m][n][mP];
    }
};

这是二维ac代码

class Solution {
public:
    int profitableSchemes(int n, int mP, vector<int>& g, vector<int>& p) 
    {
        const int a = 1e9 + 7;
        int m = g.size();
        vector<vector<int>> dp(n + 1, vector<int>(mP + 1));
        for(int j = 0; j <= n; ++j)
            dp[j][0] =1;
        for(int i = 1; i <= m; ++i)
            for(int j = n; j >= g[i - 1]; --j)
                for(int k = 0; k <= mP; ++k)
                    dp[j][k] = (dp[j][k] + dp[j - g[i - 1]][max(0, k - p[i - 1])]) % a;

        return dp[n][mP];
    }
};

这是一维ac代码

D.似包非包

11.组合总数IV

给你一个由不同整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。

题目数据保证答案符合 32 位整数范围

1.状态表示：用dp[ i ]表示数 i 被构造的排列次数

2.状态转移方程：dp[ i ] += dp[ i - x ];

3.初始化：dp[ 0 ] = 1

4.填表顺序：从左往右

5.返回值：dp[ target ]

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) 
    {
        vector<double> dp(target + 1);
        dp[0] = 1;
        for(int i = 1; i <= target; ++i)
            for(auto x : nums)
                if(i >= x)
                    dp[i] += dp[i - x];

        return dp[target];
    }
};

这是ac代码

12.不同的二叉搜索树

96. 不同的二叉搜索树

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。

1.状态表示：用dp[ i ]表示 1 到 n 可以组成二叉搜索数的个数

2.状态转移方程：dp[ i ] += dp[ k - 1 ] * dp[ i - k ] ;

3.初始化：dp[ 0 ] = 1

4.填表顺序：从左往右

5.返回值：dp[ n ]

class Solution {
public:
    int numTrees(int n) 
    {
        vector<int> dp(n + 1);
        dp[0] = 1;
        for(int i = 1; i <= n; ++i)
            for(int k = 1; k <= i; ++k)
                dp[i] += dp[k - 1] * dp[i - k];
        
        return dp[n];
    }
};

这是ac代码