(完全背包型动态规划)lintcode440 · 背包问题 III

最新推荐文章于 2024-06-10 00:23:34 发布

White boy&

最新推荐文章于 2024-06-10 00:23:34 发布

阅读量117

点赞数 2

文章标签：动态规划算法

本文链接：https://blog.csdn.net/weixin_46035615/article/details/123631199

版权

题目

描述
给定 n 种物品, 每种物品都有无限个. 第 i 个物品的体积为 A[i], 价值为 V[i].
再给定一个容量为 m 的背包. 问可以装入背包的最大价值是多少?

1.不能将一个物品分成小块.
2.放入背包的物品的总大小不能超过 m.

样例

样例 1:
输入: A = [2, 3, 5, 7], V = [1, 5, 2, 4], m = 10
输出: 15
解释: 装入三个物品 1 (A[1] = 3, V[1] = 5), 总价值 15.

样例 2:
输入: A = [1, 2, 3], V = [1, 2, 3], m = 5
输出: 5
解释: 策略不唯一. 比如, 装入五个物品 0 (A[0] = 1, V[0] = 1).

分析

1.算法选择

题目可以装入的物品数量不限，求可以装入背包的最大价值，典型的完全背包问题，第一步想到的是动态规划，然后就是贪心，这种题用动态规划肯定是没问题。
反观一下贪心，贪心准则肯定是性价比高的优先，但是这道题中物品是不可分割的，反例：A=[3,5],V=[3,4],m=11;利用贪心准则重量为3的物品性价比是最高的，所以都装入3最大价值为9，但是这道题正确的做法是2个3，1个5最大价值为10
如果非要用贪心的话，贪心准则将会非常复杂，准则是价值，重量，性价比都有反例，所以这里我们选择用动态规划

2.确定最后一步

f[i],[j]代表着选i种物品时凑齐j重量的最大价值，最后一步是是否拿A[i],那就要比较f[i-1],[j]和f[i],[j-A[i]]的大小。

如果看了上一篇背包问题二这里就看出了不同之处，上一个是跟f[i-1],[j-A[i]]比较，只有这一处不一样，这里是怎么思考的呢，背包二中的每个物品只有一个，所以拿这个物品要从前一行来算，而背包三物品有无限多个，从当前行算的意思就是说可以拿多个这个物品

3.转移方程

f[i],[j]=max(f[i-1],[j] f[i],[j-A[i]]+V[i]),这里的条件是j>=A[i] 当前背包的承重不小于当前物品的重量&&当前比较的这个状态是可以拼出来的

代码部分

1.初始化

背包的承重m当作列，物品的种类n当作行，并且初始化第一行，就是当物品种类为0时对应的价值，f[0],[0]=0因为这时需要装满0的重量所以什么都不用做，价值为0，往后就是(0,1),(0,2),(0,3)…(0,m)物品种类为0时任何大于0的重量都是凑不出来的，凑不出来这里我们标记成-1

        int len=A.size();
        
        vector<vector<int> > f(len+1,vector<int>(m+1));
        
        f[0][0]=0;			//初始化第一行
		for(int i=1;i<m+1;i++)
			f[0][i]=-1;		//0种物品承重大于0时肯定拼不出来

2.动规核心

这里我初始化了一个变量来记录最大值，不然到最后还要再创建一个循环来找出最大值

		int maxval=0;
		for(int i=1;i<len+1;i++)		//动规核心 
		{
			for(int j=0;j<m+1;++j)
			{
				f[i][j]=f[i-1][j];
				if(j>=A[i-1]&&f[i][j-A[i-1]]!=-1)
					f[i][j]=max(f[i][j],f[i][j-A[i-1]]+V[i-1]);
				maxval=max(maxval,f[i][j]);
			}
		}

完整代码

class Solution {
public:

    int backPackIII(vector<int> &A, vector<int> &V, int m) {
        int len=A.size();
        
        vector<vector<int> > f(len+1,vector<int>(m+1));
        
        f[0][0]=0;			//初始化第一行
		for(int i=1;i<m+1;i++)
			f[0][i]=-1;		//0种物品承重大于0时肯定拼不出来
			
		int maxval=0;
		for(int i=1;i<len+1;i++)		//动规核心 
		{
			for(int j=0;j<m+1;++j)
			{
				f[i][j]=f[i-1][j];
				if(j>=A[i-1]&&f[i][j-A[i-1]]!=-1)
					f[i][j]=max(f[i][j],f[i][j-A[i-1]]+V[i-1]);
				maxval=max(maxval,f[i][j]);
			}
		}
		
		return maxval;
    }
};