1、问题描述
已知:有N种物品和一个容量为V 的背包,每种物品都有无限件可用。放入第i种物品的耗费的空间是C[i],得到的价值是W[i]。
求解:将哪些物品装入背包,可使这些物品的耗费的空间总和不超过背包容量,且价值总和最大?
2、基本思路
这个问题与01背包问题非常类似,不同的是每件物品有无限件。从每件物品的角度来看,它相关的策略并非取或者不取,而是有取0件、取1件、取2件... 直至取 V/C[i] 等很多种。
如果按照01背包的思路,用二维数组F[i ][ v] 表示 前i件物品恰放入一个容量恰为v的背包可以获得的最大价值,则状态转移方程为:
使用二维数组的代码如下:
package pack9jiang; import java.util.Scanner; /** * 完全背包问题,基本思路,时间复杂度较高,使用二维数组 */ public class CompletePackExtend2 { // N表示物体的个数,V表示背包的载重 int N,V; //用于存储每个物体的重量,下标从1开始 private int[] weight; //存储每个物体的收益,下标从1开始 private int[] value; //降成二维数组,用来保存每种状态下的最大收益 private int[][] F; public void CompletePackNonRecursive() { //对二维数组F进行初始化 for(int i = 0; i <= V; i++) { F[0][i] = 0; } //注意边界问题,i是从1开始的 for(int i = 1; i <= N; i++) { //j是正序、降序没影响 for (int j = 0; j <= V; j++) { for (int k = 0; k <= V / weight[i]; k++) { if (j >= k * weight[i]) { //注意:状态转移方程是F[i][j],而不是F[i - 1][j] //因为这时放k个第i个物品,之后还可能继续放这个物体,所以应是F[i][j] F[i][j] = Math.max(F[i - 1][j - k * weight[i]] + k * value[i], F[i][j]); } else { //可以省略,这里为什么不是F[i - 1][j] //因为刚开始k=0,j >= 0 * weight[i]肯定成立,此时F[i][j] = F[i - 1][j]。 F[i][j] = F[i][j]; } } } } //打印所有结果,我们要求的是F[N][V] for(int i = 0; i <= N; i++) { for(int j = 0; j <= V; j++) { System.out.print(F[i][j] + " "); } System.out.println(); } } /** * 输入格式: 5 10 2 2 6 5 4 6 3 5 4 6 result:30 * 第一行是物体个数、背包总空间; * 第二行是每个物体的空间; * 第三行是每个物体的收益。 */ public void init() { Scanner sc = new Scanner(System.in); N = sc.nextInt(); V = sc.nextInt(); //下标从1开始,表示第1个物品 weight = new int[N + 1]; value = new int[N + 1]; F= new int[N + 1][V + 1]; for(int i = 1; i <= N; i++) { weight[i] = sc.nextInt(); } for(int i = 1; i <= N; i++) { value[i] = sc.nextInt(); } } public static void main(String[] args) { CompletePackExtend2 cpe2 = new CompletePackExtend2(); cpe2.init(); cpe2.CompletePackNonRecursive(); } }
也可以用一维数组来优化空间开销,用一维数组的代码实现如下:
package pack9jiang; import java.util.Scanner; /** * 完全背包问题,基本解决思路,但是时间复杂度过高 */ public class CompletePack { // N表示物体的个数,V表示背包的载重 int N,V; //用于存储每个物体的重量,下标从1开始 private int[] weight; //存储每个物体的收益,下标从1开始 private int[] value; //降成一维数组,用来保存每种状态下的最大收益 private int[] F; public void CompletePackNonRecursive() { //对一维数组F进行初始化 for(int i = 0; i <= V; i++) { F[i] = 0; } //注意边界问题,i是从1开始的 for(int i = 1; i <= N; i++) { for(int j = V; j >= 0; j--) { for(int k = 1; k <= V/weight[i]; k++) { if(j >= k * weight[i]) { F[j] = Math.max(F[j - k * weight[i]] + k * value[i], F[j]); }else { //可以省略 F[j]= F[j]; } } } } //打印所有结果,我们要求的是F[V] for(int i = 0; i <= V; i++) { System.out.print(F[i] + " "); } System.out.println(); } /** * 输入格式: 5 10 2 2 6 5 4 6 3 5 4 6 result:30 * 第一行是物体个数、背包总空间; * 第二行是每个物体的空间; * 第三行是每个物体的收益。 */ public void init() { Scanner sc = new Scanner(System.in); N = sc.nextInt(); V = sc.nextInt(); //下标从1开始,表示第1个物品 weight = new int[N + 1]; value = new int[N + 1]; F= new int[V + 1];//注意是 V + 1 for(int i = 1; i <= N; i++) { weight[i] = sc.nextInt(); } for(int i = 1; i <= N; i++) { value[i] = sc.nextInt(); } } public static void main(String[] args) { CompletePack cp = new CompletePack(); cp.init(); cp.CompletePackNonRecursive(); } }
分析算法复杂度:
程序需要求解N*V个状态,每一个状态需要求出的时间为O(V/weight[i]),总的时间复杂度为O(NV*∑(V/weight[i]))。
一个简单有效的代码优化:
若两件物品i、j满足value[i] <= value[j] 且 weight[i] >= weight[j],则可以将物品j直接去掉,不予考虑。
即,如果一个物品A占空间少且价值高,而物品B占空间多但价值不高,那么肯定优先考虑物品A的。
对于随机生成的数据,这个方法往往能大大减少物品的件数,从而加快速度。但是在最快情况下,可能一件物品也去不掉,这个优化可以简单的用O(n^2)地实现,一般能承受。
========================
代码待添加
========================
3、转化为01背包问题求解
思路一:完全背包的物品可以取无限件,我们直接改变第i件物品的总个数,使之达到 V/weight[i] 件,之后直接利用01背包的思路进行求解。
时间复杂度分析:这种方法完全没有改进时间复杂度,因为拆分后的物品总数量很大,时间复杂度为O(V * ∑(V/weight[i]))
思路二:采用二进制的思想对物品进行拆分,可以减少拆分物品的总数量。
具体思路:把第i中物品拆分成费用为weight[i]*(2^k)、价值为value[i]*(2^k)的若干件物品,其中k满足weight[i]*(2^k) <= V,其中k从0开始取值。
时间复杂度分析:拆分后的物品总数量为num = ∑ log(V/weight[i]),所以时间复杂度为 O(V * num)
举例分析:假设A物品的空间为2,价值为3,背包的总空间为20。
根据思路一拆分:可以拆分成10个物品,每个物品的空间为2,价值为3;
根据思路二拆分:可以拆分为4种物品,分别是物品一(空间2*1,价值为3)、物品二(空间2*2,价值为6)、物品三(空间2*4,价值为12)、物品一(空间2*8,价值为24)。用这4个物品就可以表示思路一10个物品的所有情况,且大大减少了拆分物品的数量。
思路二的代码如下:
=========================
4、一种O(V*N)的算法(最优的解法)
这种算法使用了一维数组,伪代码如下:
发现:与01背包的一维的伪代码相比,这个伪代码仅仅只是内循环中v的循环次序不同而已。
那么为什么这个算法可行呢?
考虑01背包中为什么要按照v递减的次序循环(回顾之前的),这是为了保证在第i次循环更新F[v]之前,要用到的F[v-weight[i]]和F[v]都是第i-1次循环更新的值,还未进行第i次循环的更新以确保正确。
那么考虑完全背包问题,完全背包的特点是每种物品可以选入无限件,所以在考虑“加选一件第i种物品”这种策略时,正需要一个可能已经选择过第i种物品的子结果F[v-weight[i]]和F[v],所以就可以且必须采用v递增的顺序循环。
代码如下:
package pack9jiang; import java.util.Scanner; /** * 完全背包问题,时间复杂度为O(NV)的算法 * 与01背包的一维数组基本一样,唯一不同的就是v的遍历顺序是相反的 */ public class CompletePackExtend1 { // N表示物体的个数,V表示背包的载重 int N,V; //用于存储每个物体的重量,下标从1开始 private int[] weight; //存储每个物体的收益,下标从1开始 private int[] value; //降成一维数组,用来保存每种状态下的最大收益 private int[] F; public void CompletePackNonRecursive() { //对一维数组F进行初始化 for(int i = 0; i <= V; i++) { F[i] = 0; } //注意边界问题,i是从1开始的 for(int i = 1; i <= N; i++) { //唯一不同的地方,j是正序遍历 for(int j = 0; j <= V; j++) { if(j >= weight[i]) { F[j] = Math.max(F[j - weight[i]] + value[i], F[j]); }else { //可以省略 F[j]= F[j]; } } } //打印所有结果,我们要求的是F[V] for(int i = 0; i <= V; i++) { System.out.print(F[i] + " "); } System.out.println(); } /** * 输入格式: 5 10 2 2 6 5 4 6 3 5 4 6 result:30 * 第一行是物体个数、背包总空间; * 第二行是每个物体的空间; * 第三行是每个物体的收益。 */ public void init() { Scanner sc = new Scanner(System.in); N = sc.nextInt(); V = sc.nextInt(); //下标从1开始,表示第1个物品 weight = new int[N + 1]; value = new int[N + 1]; F= new int[V + 1];//注意是 V + 1 for(int i = 1; i <= N; i++) { weight[i] = sc.nextInt(); } for(int i = 1; i <= N; i++) { value[i] = sc.nextInt(); } } public static void main(String[] args) { CompletePackExtend1 cpe1 = new CompletePackExtend1(); cpe1.init(); cpe1.CompletePackNonRecursive(); } }