当前位置：首页 > news >正文

[dp20_完全背包] 介绍 | 零钱兑换

news 来源：原创 2025/4/20 5:10:28

1. 完全背包

题解

背包必须装满

2.零钱兑换

题解

1. 完全背包

链接： DP42 【模板】完全背包

描述

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

现在有n种物品，每种物品有任意多个，第i种物品的体积为vivi ,价值为wiwi。

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

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

输入描述：

第一行两个整数n和V，表示物品个数和背包体积。
接下来n行，每行两个数vi和wi，表示第i种物品的体积和价值。
1≤n,V≤10001≤n,V≤1000

输出描述：

输出有两行，第一行输出第一问的答案，第二行输出第二问的答案，如果无解请输出0。

示例1

输入：

2 6
5 10
3 1

复制

输出：

10
2

复制

示例2

输入：

复制

输出：

20
0

复制

说明：无法恰好装满背包。

示例3

输入：

复制

输出：

596
189

复制

说明：可以装5号物品2个，达到最大价值298*2=596，若要求恰好装满，只能装1个1号物品，价值为189.

题解

解决第一问背包没有必要装满的情况

之前在01背包哪里说过其他背包问题都是从01背包延伸的，所以01背包是其他背包的基础。
接下来的状态表示、状态转移方程等全都是按照01背包来的。
01 背包前文：[dp18_背包问题] 介绍 | 01背包 | 分割等和子集

1.状态表示

dp[i][j] 表示：从前 i 个物品中选，总体积不超过 j ，所有选法中，最大价值是多少。

2.状态转移方程

这里也是和01背包那里一样，根据最后一个位置，划分情况。
但是这里有点差别，01背包哪里只有选or不选两个情况，我们这里情况就多了。
可以不选、可以选1个、可以选2个、可以选3个…

不选 i，说明所有选法中都不包含第 i 个物品，相当于从去 1 ~ i - 1 这个区间去选，就是dp[i-1][j]

选一个 i，这时就有一个v[i]的体积了，然后仅需去 1 ~ i - 1 区间去选一个不超过j - v[i]的最大价值，然后在加上 i 的价值。
选两个 i，这时就有两个v[i]的体积了，然后仅需去 1 ~ i - 1 区间去选一个不超过j - 2*v[i]的最大价值，然后在加上两个 i 的价值。
选三个 i，选四个…，同理如上。

如果做过前面的通配符匹配和正则表达式的时候，我们是遇到这种状态转移方程的。

发现填一个状态的时候发现这个状态时候很多状态拼接而成的，这个时候我们要想到策略把这些状态用一个或者两个状态来表示。

优化：数学

假设最后选了k个i，在选背包容量就装不下了。

我们发现 i - 1 是没有变的，但是 j 是均匀减v[i]，所以我们可以转化一下

先分析一下，k和x是否相等。上面的k表示，j - kv[i] 无限接近于0，下面的x其实也是表示，j - xv[i] 无线接近于0。
所以 k == x，也就说上面划线的和下面的个数是完全相同的。
然后我们给下面的加上一个w[i]，你会发现上面划线的完全可以用下面的替代。

dp[i] [j-v[i]] : 保留 i, 来表示当前物品还可选

因此我们就可以得到优化后的dp[i][j]的状态转移方程。

dp[i][j]=max(dp[i-1][j], dp[i][j-
注意 j - v[i] 可能不存在，这里和01背包一样，所以必须 j >= v[i]

3.初始化

多开一行一列

里面的值要保证后序的填表是正确的
下标的映射关系

第一列不用初始化前面01背包应用已经解释过了。
第一行表示物品为空，当 j 为0的时候，要凑成不超过 j，只要不选就行了，最大价值是0。
如果j为1、2、3但是没有物品可选，同样最大价值也是0.

4.填表

填dp[i][j]会用到上面和左边的值，因此从上往下填写每一行，每一行从左往右。

5.返回值

dp[i][j] 表示：从前 i 个物品中选，总体积不超过 j ，所有选法中，最大价值是多少。
我们要的是从整个物品中选不超过V的最大价值。因此返回dp[n][V]

背包必须装满

在之前的基础上稍加修改就行

1.状态表示

dp[i][j] 表示：从前 i 个物品中选，总体积不超过 j，所有选法中，最大价值是多少---->
dp[i][j] 表示：从前 i 个物品中选，总体积等于 j，所有选法中，最大价值是多少

2.状态转移方程

这里稍微修改的是dp[i][j-v[i]] + w[i]，我们之前只是判断 j - v[i] 是否存在。因为我们这里是必须要装满，但是dp[i][j-v[i]]不一定装满。如果不一定装满用0表示的话，因为后面加个w[i]，dp[i][j]求max就可能会用到这个状态。但是实际上要求如果dp[i][j-v[i]]凑不够是不能用dp[i][j-v[i]] + w[i]。所以不仅要判断 j >= v[i]，还要判断dp[i][j-v[i]情况是否存在。

我们这里和01背包哪里一样，用dp[i][j] == -1 表示情况不存在，表示 根本凑不出 j 体积
为什么不用0，因为第一行第一个空格dp[0][0] == 0 ，0 表示背包为 0 的时候选择 0 个物品，和凑不出来背包，进行了区分
dp[i][j-v[i]] !=-1 每次 max 更新前，要先进行判断！！！！

3.初始化

这里我们处理第一行就行了，第一列还是不用初始化
第一行，没有物品肯定无法装满背包，给 -1.

4.填表

从上到下
从左往右

5.返回值

注意如果最终结果是-1，说明说明始终无法装满背包，最大价值返回 0

dp[i][j]==-1 ? 0:dp[i][j]

#include <bits/stdc++.h>
using namespace std;const int N=1005;
int v[N],w[N];
int dp[N][N];int main() 
{int n,V;cin>>n>>V;for(int i=0;i<n;i++){cin>>v[i]>>w[i];}int ret=0;
//不用装满memset(dp,0,sizeof dp);for(int i=1;i<=n;i++){for(int j=0;j<=V;j++){dp[i][j]=dp[i-1][j];//注意 下标映射if(j>=v[i-1])dp[i][j]=max(dp[i][j],dp[i][j-v[i-1]]+w[i-1]);}}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=0;j<=V;j++){dp[i][j]=dp[i-1][j];
//注意 下标映射if(j>=v[i-1] && dp[i][j-v[i-1]]!=-1)dp[i][j]=max(dp[i][j],dp[i][j-v[i-1]]+w[i-1]);}}cout<<(dp[n][V]==-1?0:dp[n][V]);return 0;
}

我们也可以增强可读性的，这么解决下标映射问题

直接将空间开的足够大，从 1 位置开始输入数组~

01 背包的滚动数组优化

j 变化方向
判断条件加入循环中，实现剪枝
只和上一行有关

那么完全背包呢

我们搞成一个数组，直接把横坐标 i 干 xx 掉。
如果填 j 位置，也需要之前上一行的状态和同一行前面的状态，因此从左往右遍历。

#include <bits/stdc++.h>
using namespace std;const int N=1005;
int v[N],w[N];
int dp[N];int main() 
{int n,V;cin>>n>>V;for(int i=0;i<n;i++){cin>>v[i]>>w[i];}int ret=0;
//不用装满memset(dp,0,sizeof dp);for(int i=1;i<=n;i++){for(int j=v[i-1];j<=V;j++){dp[j]=max(dp[j],dp[j-v[i-1]]+w[i-1]);}}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-1];j<=V;j++){
//注意 下标映射if(dp[j-v[i-1]]!=-1)dp[j]=max(dp[j],dp[j-v[i-1]]+w[i-1]);}}cout<<(dp[V]==-1?0:dp[V]);return 0;
}

优化的完全背包代码如果和01背包代码相比，你会发现它们俩只有遍历顺序不一样

01背包是从 V -> v[i]
完全背包是从 v[i] -> V，其他代码都是一样的。

其实这里还有一点点优化，有的人这里不用判断if，发现它的代码也过了。

我们这里放个if，主要是为了防止dp[j-v[i]] + w[i]不合法就用了，所以加了一个if。
其实不加if也可以做到，合法用，不合法不用。因为这里求的是max，我只要让它不合法的时候值足够小就行了，即使求max它也没有用。

如何才能让它足够小呢？

我们可以初始第一行不给它设为-1，因为-1加一个正数可能是一个正数。而是设置为-0x3f3f3f3f。
首先这个数足够小，其次这个数用来做加法极有可能不会超过0。
如果你设置为INT_MIN，如果是 - w[i] 就会溢出，溢出之后就会变成一个非常大的正数。

最后判断也要改一下。

2.零钱兑换

链接： 322. 零钱兑换

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

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

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

示例 1：

输入：coins = [1, 2, 5], amount = 11
输出：3 
解释：11 = 5 + 5 + 1

示例 2：

输入：coins = [2], amount = 3
输出：-1

示例 3：

输入：coins = [1], amount = 0
输出：0

有一堆硬币，从这些硬币中选一些硬币，看能凑成总金额amount所需的最少的硬币个数。

这是一个典型的背包问题。
你可以认为每种硬币的数量是无限的，这句话很重要。
看到这个无限，你就要想到这是一个完全背包问题。

题解

1.状态表示

dp[i][j] 表示：从前 i 个硬币中挑选，总和正好等于j，所有选法中，最少硬币个数。

2.状态转移方程

根据最后一个位置，划分情况
不选 i，说明所有选法中都不包含第 i 个硬币，相当于从去 1 ~ i - 1 这个区间去选，就是dp[i-1][j]

选1个i，这时就有 i 这个硬币了，然后仅需去 1 ~ i - 1 区间去选一个不超过j - coins[i]的最少硬币个数，然后在加上 i 这个硬币个数

同理，选2个 i、选3个 i都是上面的分析思路

发现填一个状态的时候发现这个状态时候很多状态拼接而成的，这个时候我们要想到策略把这些状态用一个或者两个状态来表示。
在完全背包哪里我们已经分析过了，这里直接写，然后我们取所有情况的最小值。

3.初始化

多开一行一列
里面的值要保证后序的填表是正确的
下标的映射关系

第一列不用初始化，因为用到dp[i][j-coins[i]] 前提 j >= coins[i]，所以不会越界。

我们只初始化第一行。

第一行表示硬币为空，当 j = 0表示总和为0，不选就行了

当 j = 1、2、3…，硬币为空，根本凑不出总和是这些的情况。之前完全背包说过这些都给-1然后特判一下，但是在优化的时候有说过这些无效的情况仅需不让它们参与我们求dp[i][j]就可以了
这里我们求得是min，因此我们可以给这些位置初始化为无穷大，这样即使情况不存在求min也不会影响。

注意这里给无穷大不能给INT_MAX，

首先 INT_MAX + 1 会越界Leetcode会报错
其次INT_MAX + 1 会是一个很小的数求min就会用到它。
这里我们可以给0x3f3f3f3f，可以保证在这个算法中它是最大的，并且用来做加法也不会越界。

4.填表顺序

填dp[i][j]会用到上面和左边的值，
因此从上往下填写每一行，每一行从左往右。

5.返回值

dp[i][j] 表示：从前 i 个硬币中挑选，总和正好等于j，所有选法中，最少硬币个数。

我们要的是从整个数组中选，总和等于amount，最少硬币个数，因此返回dp[n][amount]
但是可能整个数组也凑不出总和等于amount，所以返回判断一下
dp[n][amount] >= INF ? -1 : dp[n][amount]

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

优化

只和上一行有关

class Solution {const int INF=0x3f3f3f3f;public:int coinChange(vector<int>& coins, int amount) {int n=coins.size();vector<int> dp(amount+1,INF);dp[0]=0;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];}
};