【转】 背包问题——“完全背包”详解及实现（包含背包具体物品的求解）

完全背包是在N种物品中选取若干件（同一种物品可多次选取）放在空间为V的背包里，每种物品的体积为C1，C2，…，Cn，与之相对应的价值为W1,W2，…，Wn.求解怎么装物品可使背包里物品总价值最大。

动态规划（DP）：

1） 子问题定义：F[i][j]表示前i种物品中选取若干件物品放入剩余空间为j的背包中所能得到的最大价值。

2） 根据第i种物品放多少件进行决策

     （备注:应该还有一项f[i-1][j])        (2-1)

其中F[i-1][j-K*C[i]]+K*W[i]表示前i-1种物品中选取若干件物品放入剩余空间为j-K*C[i]的背包中所能得到的最大价值加上k件第i种物品；

设物品种数为N，背包容量为V，第i种物品体积为C[i]，第i种物品价值为W[i]。

与01背包相同，完全背包也需要求出NV个状态F[i][j]。但是完全背包求F[i][j]时需要对k分别取0,…，j/C[i]求最大F[i][j]值,耗时为j/C[i]。那么总的时间复杂度为O(NV∑(j/C[i]))

由此写出伪代码如下：

[cpp] view plaincopy

  1. F[0][] ← {0}
  2. F[][0] ← {0}
  3. for i←1 to N
  4. do for j←1 to V
  5. do for k←0 to j/C[i]
  6. if(j >= k*C[i])
  7. then F[i][k] ← max(F[i][k],F[i-1][j-k*C[i]]+k*W[i])
  8. return F[N][V]

以上伪代码数组均为基于1索引，即第一件物品索引为1。空间复杂度O(VN)、时间复杂度为O(NV∑(j/C[i]))

        简单优化：

若两件物品满足C[i] ≤C[j]&&W[i] ≥W[j]时将第j种物品直接筛选掉。因为第i种物品比第j种物品物美价廉，用i替换j得到至少不会更差的方案。

这个筛选过程如下：先找出体积大于背包的物品直接筛掉一部分（也可能一种都筛不掉）复杂度O(N)。利用计数排序思想对剩下的物品体积进行排序，同时筛选 出同体积且价值最大的物品留下，其余的都筛掉（这也可能一件都筛不掉）复杂度O(V)。整个过程时间复杂度为O(N+V)

       转化为01背包：

因为同种物品可以多次选取，那么第i种物品最多可以选取V/C[i]件价值不变的物品，然后就转化为01背包问题。整个过程的时间复杂度并未减少。如果把第i种物品拆成体积为C[i]×2k价值W[i]×2k的物品，其中满足C[i]×2k≤V。那么在求状态F[i][j]时复杂度就变为O(log2(V/C[i]))。整个时间复杂度就变为O(NVlog2(V/C[i]))

时间复杂度优化为O(NV)

将原始算法的DP思想转变一下。

设F[i][j]表示出在前i种物品中选取若干件物品放入容量为j的背 包所得的最大价值。那么对于第i种物品的出现，我们对第i种物品放不放入背包进行决策。如果不放那么F[i][j]=F[i-1][j]；如果确定放，背 包中应该出现至少一件第i种物品，所以F[i][j]种至少应该出现一件第i种物品,即F[i][j]=F[i][j-C[i]]+W[i]。为什么会是 F[i][j-C[i]]+W[i]？因为F[i][j-C[i]]里面可能有第i种物品，也可能没有第i种物品。我们要确保F[i][j]至少有一件第 i件物品，所以要预留C[i]的空间来存放一件第i种物品。

状态方程为：

          (2-2)

伪代码为：

[cpp] view plaincopy

  1. F[0][] ← {0}
  2. F[][0] ← {0}
  3. for i←1 to N
  4. do for j←1 to V
  5. F[i][j] ← F[i-1][j]
  6. if(j >= C[i])
  7. then F[i][j] ← max(F[i][j],F[i][j-C[i]]+ W[i])
  8. return F[N][V]

具体背包中放入那些物品的求法和01背包情况差不多，从F[N][V]逆着走向F[0][0]，设i=N,j=V，如果F[i][j]==F[i][j- C[i]]+W[i]说明包里面有第i件物品，同时j -= C[i]。完全背包问题在处理i自减和01背包不同，01背包是不管F[i][j]与F[i-1][j-C[i]]+W[i]相不相等i都要减1，因为 01背包的第i件物品要么放要么不放，不管放还是不放其已经遍历过了，需要继续往下遍历而完全背包只有当F[i][j]与F[i-1][j]相等时i才自 减1。因为F[i][j]=F[i-1][j]说明背包里面不会含有i，也就是说对于前i种物品容量为j的背包全部都放入前i-1种物品才能实现价值最大 化，或者直白的理解为前i种物品中第i种物品物不美价不廉，直接被筛选掉。

打印背包内物品的伪代码如下：

[cpp] view plaincopy

  1. i←N
  2. j←V
  3. while(i>0 && j>0)
  4. do if(F[i][j]=F[i][j-C[i]]+W[i])
  5. then Print W[i]
  6. j←j-C[i]
  7. else
  8. i←i-1

和01背包一样，也可以利用一个二维数组Path[][]来标记背包中的物品。开始时Path[N][V]初始化为0,当 F[i][j]==F[i][j-C[i]]+W[i]时Path[i][j]置1。最后通过从Path[N+1][V+1]逆着走向Path[0] [0]来获取背包内物品。其中Path[0][]与Path[][0]为边界。同样，在打印路径的时候当Path[][]=1时，打印 W[i]；Path[][]=0时i自减1.

加入路径信息的伪代码如下：

[cpp] view plaincopy

  1. F[0][] ← {0}
  2. F[][0] ← {0}
  3. Path[][] ← 0
  4. for i←1 to N
  5. do for k←1 to V
  6. F[i][k] ← F[i-1][k]
  7. if(k >= C[i] && F[i][k] < F[i][k-C[i]]+W[i])
  8. then F[i][k] ← F[i][k-C[i]]+W[i]
  9. Path[i][k] ← 1
  10. return F[N][V] and Path[][]

打印背包内物品的伪代码如下：

[cpp] view plaincopy

  1. i←N
  2. j←V
  3. while(i>0 && j>0)
  4. do if(Path[i][j]=1)
  5. then Print W[i]
  6. j←j-C[i]
  7. else
  8. i←i-1

优化空间复杂度为O（V）

和01背包问题一样，完全背包也可以用一维数组来保存数据。算法样式和01背包的很相似，唯一不同的是对V遍历时变为正序，而01背包为逆序。01背包中逆序是因为F[i][]只和F[i-1][]有关，且第i件的物品加入不会对F[i-1][]状态造成影响。而完全背包则考虑的是第i种物品的出现的问题，第i种物品一旦出现它势必应该对第i种物品还没出现的各状态造成影响。也就是说，原来没有第i种物品的情况下可能有一个最优解，现在第i种物品出现了，而它的加入有可能得到更优解，所以之前的状态需要进行改变，故需要正序。

状态方程为：

          (2-3)

伪代码如下：

[cpp] view plaincopy

  1. F[] = {0}
  2. for i←1 to N
  3. do for k←C[i] to V
  4. F[k] ← max(F[k],F[k-C[i]]+W[i])
  5. return F[V]

具体背包中放入那些物品的求法和上面空间复杂度为O(NV)算法一样，用一个Path[][]记录背包信息。但这里面是当F[i]=F[i-C[i]]+W[i]时将Path置1.

伪代码如下：

[cpp] view plaincopy

  1. F[0][] = {0}
  2. F[][0] = {0}
  3. Path[][] ← 0
  4. for i←1 to N
  5. do for k←C[i] to V
  6. if(F[i] < F[k-C[i]]+W[i])
  7. then F[i] ← F[k-C[i]]+W[i]
  8. Path[i][k] ← 1
  9. return F[N][V] and Path[][]

打印路径的伪代码和前面未压缩空间复杂度时的伪代码一样，这里不再重写。

举例：表2-1为一个背包问题数据表，设背包容量为10根据上述解决方法可得到对应的F[i][j]如表2-2所示，最大价值即为F[6][10].

表2-1背包问题数据表

物品号i 1 2 3 4 5 6
体积C 3 2 5 1 6 4
价值W 6 5 10 2 16 8

表2-2前i件物品选若干件放入空间为j的背包中得到的最大价值表

  0 1 2 3 4 5 6 7 8 9 10
0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 6 6 6 12 12 12 18 18
2 0 0 5 6 10 11 15 16 20 21 25
3 0 0 5 6 10 11 15 16 20 21 25
4 0 2 5 7 10 12 15 17 20 22 25
5 0 2 5 7 10 12 16 18 21 23 26
6 0 2 5 7 10 12 16 18 21 23 26

下面针对前面提到的表2-1提供两种方法的测试代码：

 

[cpp] view plaincopy

  1. #include <iostream>
  2. #include <cstring>
  3. #include "CreateArray.h"        //该头文件用于二维数组的创建及销毁，读者自己实现
  4. using namespace std;

//时间复杂度O(VN),空间复杂度为O(VN)

[cpp] view plaincopy

  1. int Package02(int Weight[], int Value[], int nLen, int nCapacity)
  2. {
  3. int** Table = NULL;
  4. int** Path = NULL;
  5. CreateTwoDimArray(Table,nLen+1,nCapacity+1);    //创建二维数组
  6. CreateTwoDimArray(Path,nLen+1,nCapacity+1); //创建二维数组
  7. for(int i = 1; i <= nLen; i++)
  8. {
  9. for(int j = 1; j <= nCapacity; j++)
  10. {
  11. Table[i][j] = Table[i-1][j];
  12. if(j >= Weight[i-1] && Table[i][j] < Table[i][j-Weight[i-1]]+Value[i-1])
  13. {
  14. Table[i][j] = Table[i][j-Weight[i-1]]+Value[i-1];
  15. Path[i][j]=1;
  16. }
  17. }
  18. }
  19. int i = nLen, j = nCapacity;
  20. while(i > 0 && j > 0)
  21. {
  22. if(Path[i][j] == 1)
  23. {
  24. cout << Weight[i-1] << " ";
  25. j -= Weight[i-1];
  26. }
  27. else
  28. i--;
  29. }
  30. cout << endl;
  31. int nRet = Table[nLen][nCapacity];
  32. DestroyTwoDimArray(Table,nLen+1);   //销毁二维数组
  33. DestroyTwoDimArray(Path,nLen+1);    //销毁二维数组
  34. return nRet;
  35. }

//时间复杂度O(VN)，不考虑路径空间复杂度为O(V)，考虑路径空间复杂度为O(VN)

[cpp] view plaincopy

  1. int Package02_Compress(int Weight[], int Value[], int nLen, int nCapacity)
  2. {
  3. int * Table = new int [nCapacity+1];
  4. memset(Table,0,(nCapacity+1)*sizeof(int));
  5. int** Path = NULL;
  6. CreateTwoDimArray(Path,nLen+1,nCapacity+1);     //创建二维数组
  7. for(int i = 0; i < nLen; i++)
  8. {
  9. for(int j = Weight[i]; j <=nCapacity; j++)
  10. {
  11. if(Table[j] < Table[j-Weight[i]]+Value[i])
  12. {
  13. Table[j] = Table[j-Weight[i]]+Value[i];
  14. Path[i+1][j] = 1;
  15. }
  16. }
  17. }
  18. int i = nLen, j = nCapacity;
  19. while(i > 0 && j > 0)
  20. {
  21. if(Path[i][j] == 1)
  22. {
  23. cout << Weight[i-1] << " ";
  24. j -= Weight[i-1];
  25. }
  26. else
  27. i--;
  28. }
  29. cout << endl;
  30. int nRet = Table[nCapacity];
  31. DestroyTwoDimArray(Path,nLen+1);    //销毁二维数组
  32. delete [] Table;
  33. return nRet;
  34. }

测试代码：

[cpp] view plaincopy

  1. int main()
  2. {
  3. int Weight[] = {3,2,5,1,6,4};
  4. int Value[] =  {6,5,10,2,16,8};
  5. int nCapacity = 10;
  6. cout << Package02(Weight,Value,sizeof(Weight)/sizeof(int),nCapacity) << endl;
  7. cout << Package02_Compress(Weight,Value,sizeof(Weight)/sizeof(int),nCapacity) << endl;
  8. return 0;
  9. }

本文部分内容参考“背包九讲”

转自http://blog.csdn.net/wumuzi520/article/details/7014830 感谢！

时间： 2024-10-14 12:36:41

【转】 背包问题——“完全背包”详解及实现（包含背包具体物品的求解）的相关文章

【转】背包问题——“01背包”详解及实现（包含背包中具体物品的求解）

01背包是在M件物品取出若干件放在空间为W的背包里,每件物品的体积为C1,C2,…,Cn,与之相对应的价值为W1,W2,…,Wn.求解将那些物品装入背包可使总价值最大. 动态规划(DP): 1) 子问题定义:F[i][j]表示前i件物品中选取若干件物品放入剩余空间为j的背包中所能得到的最大价值. 2) 根据第i件物品放或不放进行决策                         (1-1) 其中F[i-1][j]表示前i-1件物品中选取若干件物品放入剩余空间为j的背包中所能得到的最大价值: 而

动态规划01背包问题（例子详解）

附上原文地址:http://www.cnblogs.com/sdjl/articles/1274312.html ----第一节----初识动态规划-------- 经典的01背包问题是这样的: 有一个包和n个物品,包的容量为m,每个物品都有各自的体积和价值,问当从这n个物品中选择多个物品放在包里而物品体积总数不超过包的容量m时,能够得到的最大价值是多少?[对于每个物品不可以取多次,最多只能取一次,之所以叫做01背包,0表示不取,1表示取] 为了用一种生动又更形象的方式来讲解此题,我把此题用另一

背包问题(知识概念详解)

通过:http://www.cnblogs.com/tanky_woo/archive/2010/07/31/1789621.html 改编而来 3种背包的简单概念: 0-1背包  (ZeroOnePack): 有N件物品和一个容量为V的背包.每种物品均只有一件 第i件物品的费用是c[i],价值是w[i].求解将哪些物品装入背包可使价值总和最大. 完全背包(CompletePack): 有N种物品和一个容量为V的背包,每种物品都有无限件可用.  第i种物品的费用是c[i],价值是w[i].求解将

$01背包详解$

前言:DP 快接触半年了. 还是想起来把曾经虐我的\(01背包\) 好好写写. \[ dp[i][j] \ = \ max(\ dp[i-1][j-w[i]] \ + \ c[i] \ , \ dp[i][j])\;\] \[ 这个方程熟悉吗qwq \] \[ 以及下面这个压维的.\] \[ dp[j] \ = \ max(\ dp[j-w[i]] \ + \ c[i] \ , \ dp[j])\;\] 本文不多占篇幅 例题就写在这里.(抄袭代码后果自负 下面借鉴此处 其中\(F[i-1][j]

动态规划之01背包详解【解题报告】

01背包问题,是用来介绍动态规划算法最经典的例子,网上关于01背包问题的讲解也很多,我写这篇文章力争做到用最简单的方式,最少的公式把01背包问题讲解透彻. 01背包的状态转换方程 f[i,j] = Max{ f[i-1,j-Wi]+Pi( j >= Wi ),  f[i-1,j] } f[i,j]表示在前i件物品中选择若干件放在承重为 j 的背包中,可以取得的最大价值. Pi表示第i件物品的价值. 决策:为了背包中物品总价值最大化,第 i件物品应该放入背包中吗 ? 题目描述: 有编号分别为a,b

背包之01背包、完全背包、多重背包详解

首先说下动态规划,动态规划这东西就和递归一样,只能找局部关系,若想全部列出来,是很难的,比如汉诺塔.你可以说先把除最后一层的其他所有层都移动到2,再把最后一层移动到3,最后再把其余的从2移动到3,这是一个直观的关系,但是想列举出来是很难的,也许当层数n=3时还可以模拟下,再大一些就不可能了,所以,诸如递归,动态规划之类的,不能细想,只能找局部关系. 1.汉诺塔图片 (引至杭电课件:DP最关键的就是状态,在DP时用到的数组时,也就是存储的每个状态的最优值,也就是记忆化搜索) 要了解背包,首先得清楚

背包详解

博客链接:http://www.cnblogs.com/tanky_woo/archive/2010/07/31/1789621.html 01背包: 题目地址:http://acm.hdu.edu.cn/showproblem.php?pid=2602 代码: 1 #include <algorithm> 2 #include <iostream> 3 #include <sstream> 4 #include <cstdlib> 5 #include &

完全背包详解_动态规划

题目描述 设有n种物品,每种物品有一个重量及一个价值.但每种物品的数量是无限的,同时有一个背包,最大载重量为M,今从n种物品中选取若干件(同一种物品可以多次选取),使其重量的和小于等于M ,而价值的和为最大. 输入 第一行:两个整数,M(背包容量,M<=200)和N(物品数量,N<=30):第2..N+1 行:每行二个整数Wi,Ui,表示每个物品的重量和价值. 输出 仅一行,一个数,表示最大总价值,格式如样例. 样例输入 10 4 2 1 3 3 4 5 7 9 样例输出 max=12 解析

背包问题详解

01背包 一个背包中容量为V,现在有N个物品,每个物品的第i个 物品体积为weight[i],价值为value[i],现在往背包里面装东西,怎么装能使背包的内物品价值最大?这是01背包的最基础最根本的问题.01代表的意思是该物品取或者不取.顺便提一下各种背包之间的区别,完全背包每种物品的数目是无限种,多重背包的每种物品数目是有限中. 用子问题定义状态:即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值.则其状态转移方程便是: f[i][v]=max{f[i-1][v],f[