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

于 2024-05-08 22:43:32 发布
阅读量913 收藏 19
点赞数 15
文章标签： 动态规划 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80764270/article/details/138548069
版权

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

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 ]

注意：由于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][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代码

云淡风轻kk
关注
动态规划之填表法
shxifs的博客
10-03 2778
动态规划基本上都需要开辟一个数组来记录状态, 数组是基于所给条件利用动归方程把表填满. 现在总结一下填表的注意事项. 1.表的行数是所给条件的索引数+1 2.dp表第一行(或第一列)需要根据实际条件初始化 例子: 给定字符串s和t，判断s是否为t的子序列。(可以不连续) 动态规划方程为:(dp[i][j]表示长度为i的s串是否是长度为j的t串的子序列) if(s[i]...
动态规划题集（背包问题等）
瓦刀
05-23 463
有了四步解题法模板，再也不害怕动态规划！ 例题 120. 三角形最小路径和 class Solution { public int minimumTotal(List<List<Integer>> triangle) { for(int i = triangle.size()-1; i > 0 ; i--){ for(int j = 0; j < i ; j++){ triangle.get(
背包问题动态规划编程题集合（leetcode)
qq_43649937的博客
03-19 394
java
动态规划——背包问题
最新发布
2301_76553467的博客
03-19 347
此时我们选择逆序遍历max_value[j]，因为j是逆序循环，max_value[j]会先于max_value[j - w[i]]更新，也就是说，用旧值max_value[j - w[i]] 去更新max_value[j]，相当于上一行（上一个i）的max_value[j - w[i]] 去更新max_value[j]，就不会出错。优化空间复杂度前模板 (时间复杂度O（nm），空间复杂度（nm）)优化空间复杂度后模板（时间复杂度O（nm），空间复杂度O（m））多重背包问题的二进制优化。
程序员常用十大算法(三):动态规划算法(填表法）解决01背包问题
qq_45273552的博客
10-27 1919
动态规划算法（填表法） 基本介绍： 1）动态规划算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法。 2）动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解 3）与分治法不同的是，适用于动态规划算法求解的问题，经分解得到子问题往往不是相互独立的。（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解。） 4）动态规划算法可以通过填表的方式来逐步推进，得到最优解。 案例引入： 背包问题： 现有
家具企业问题分析与决策专训.pptx
10-20
【家具企业问题分析与决策专训】 在家具企业的运营中，管理层经常面临各种问题，这些问题可能涉及生产、销售、人力资源、财务等多个方面。对于这些问题的分析与决策是企业能否持续发展和保持竞争力的关键。这份...
江苏专用2020高考生物二轮复习考前预测押题专训8道非选择题增分练三
09-08
8. 基因遗传与表现型：萨卢基犬的毛色受两对独立遗传的基因B、b和I、i控制，其中基因I会抑制B和b的表达，表现为白色。根据遗传规律，可以通过系谱图分析个体的基因型和表现型。 9. 纯合子与杂合子概率：通过遗传学...
江苏专用2020高考生物二轮复习考前预测押题专训8道非选择题增分练一
09-08
8. 基因型推断：II5携带甲病(Dd)和乙病(X^FX^f)的基因，其致病基因可能来自双亲。 9. 遗传概率计算：若III12与III13结婚，他们生育一个同时患有甲、乙两种病的孩子的概率取决于两病基因的组合和遗传规律。 10. ABO...
江苏专用2020高考生物二轮复习考前预测押题专训8道非选择题增分练二
09-08
【知识点】 1. 细胞结构与功能： - 微绒毛的作用：微绒毛是细胞表面的小突起，可以显著增大细胞的表面积，从而增加消化和吸收的效率。 - 细胞器的功能：小肠上皮细胞合成和分泌消化酶涉及的细胞器包括核糖体...
基于数据库的多媒介营销专训.ppt
11-17
1. **传统营销的挑战**：传统营销面临的问题包括营销成本增加、收入与支出比例失衡、反馈率和转化率下降。这表明单靠传统方式已经无法满足当前市场的竞争需求。 2. **立体营销**：立体营销是应对挑战的一种策略，它...
leetcode410:分割数组的最大值_填表法求解动态规划
07-28
leetcode04_寻找两个正序数组的中位数解法.rar !!!CSDN的一个特性: 即使我设置成免费下载,被下载的次数多了之后也会变成付C币下载的了,这个很头疼. !!!因此如果没有C币但想要下载的朋友可以在b站视频下留言给我,留下你的邮箱,我看到了就会发给你.(不要在CSDN上留言,CSDN有时候会出bug不显示私信内容,很烦人). 文字版讲义见:https://blog.csdn.net/ncepu_Chen/article/details/107625127 视频版本讲义见: https://www.bilibili.com/video/BV1X54y1S7hh/
动态规划-常见做法：填表法
洛谷棕名用户的博客（兔子的博客）
07-22 2090
填表法 引入 填表法，是DP最常见的做法。 以未知的量为基础，通过已知的量来刷新当前的未知量。 例图 思路 推荐刷题 洛谷P1048 采药（传送门） 洛谷P1006 传纸条（传送门） ...
最短编辑距离（动态规划超详细填表法）
mysterious superstar
12-08 999
链接：https://www.nowcoder.com/questionTerminal/9649617be3bf42288f50758df4310655 来源：牛客网 UNIX系统下有一个行编辑器ed，它每次只对一行文本做删除一个字符、插入一个字符或替换一个字符三种操作。例如某一行的内容是“ABC”，经过把第二个字符替换成“D”、删除第一个字符、末尾插入一个字符“B”，这三步操作后，内容就...
动态规划法
longshengguoji的专栏
04-15 7025
1.定义及性质         动态规划是一种在数学、计算机科学和经济学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。 动态规划常常适用于有重叠子问题[1]和最优子结构性质的问题，用时往往远少于朴素解法。 动态规划背后的基本思想非常简单。大致上，若要解一个给定问题，我们需要解其不同部分（即子问题），再合并子问题的解以得出原问题的解。 通常许多子问题非常相似，为此
动态规划刷表法
AI_xue
08-13 7328
一.先简单讲下什么是填表法，什么是刷表法。 填表法 ：就是一般的动态规划，当前点的状态，可以直接用状态方程，根据之前点的状态推导出来。 刷表法：由当前点的状态，更新其他点的状态。需要注意：只用当每个状态所依赖的状态对它的影响相互独立。 二.通过例题看刷表 链接：http://exam.upc.edu.cn/problem.php?id=2383 题意：三个数，T表示最大的饱腹值，A表示吃
【DP】刷表法&填表法
CH_Vaniteux的博客
02-05 2486
今天偶然在洛谷上读到某大佬的DP常用方法：刷表法&填表法 “填表法就是利用状态转移方程和上一个状态来推导出现在的状态（相当于知道已知条件，将答案填入） 刷表法就是利用当前的状态，把有关联的下一状态都推出来。” 填表法就是利用状态转移方程和上一个状态来推导出现在的状态（相当于知道已知条件，将答案填入） 刷表法就是利用当前的状态，把有关联的下一状态都推出来。
动态规划表格法详细解析01背包问题
weixin_41710054的博客
08-15 4520
3.8 0-1背包问题(Knapsack problem) 前言：麻烦转载注明出处哦。 3.8.1 问题描述 其中每种物品只有1件，存放哪些物品，才能使背包存放物品价值最高？ 3.8.2 算法思路 假设背包空间只有1kg、2kg…5kg，假设可装物品只有1种、2种…4种，按照这种思想，我们可以得出下面这张表。 要填写这张表，首先要知道每个空格之间的依赖关系。 以下图的最后一张表为例：当剩余空间为3kg，剩余商品为1号(2kg,12元)、2号 (1kg,10元)，此时，我们有两种选择： 第一种，选择不放
经典算法之动态规划（Dynamic Programming）
青萍之末的博客
06-21 2830
1、动态规划的定义   动态规划，dynamic Programming，是一种高效解决问题的方法，使用与具有重复子问题和最优子结构的问题。 2、动态规划的思想   动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这...
<C/C++算法>动态规划练习与小结
EbowTang的练习场
04-19 8334
一，关于“动态规划”的学习建议： Here is my answer in similar topic Start with wikipedia article about dynamic programming then I suggest you read this article in topcoder
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值