背包问题的分类
一个背包总容量为V, 现在有N个物品, 第i个物品容量为weight[i], 价值为value[i], 现在往背包里面装东西, 怎样装才能使背包内物品总价值最大.主要分为3类:
- 0-1背包, 每个物品只能取0个,或者1个.
- 完全背包, 每个物品可以取无限次.
- 多重背包, 每种物品都有个数限制, 第i个物品最多可以为num[i]个.
背包问题之回溯法,贪婪算法解法(Java版)
(1)经典的0-1背包问题(无物品的价值):
假设有一个能装入容量为C的背包和n件重量分别为w1,w2,,...,wn的物品,能否从n件物品中挑选若干件恰好装满背包,要求找出所有满足上述条件的解。当C=10,各件物品重量为{1,8,4,3,5,2}时,可以找到下列4组解:(1,4,3,2)、(1,4,5)、(8,2)和(3,5,2)。
根据这个问题的一个变形是:
已知一个数为C,一个长度为n的无序的数组,分别是数w1,w2,...,wn,能否从这n个数中找到若干个数使其和等于数C,要求找出所有满足上述条件的解。
解决思路:
本文采用的是回溯思想,利用栈的“后进先出”的特性,首先将物品排成一列,然后顺序选取物品装入背包,假设已选取了前i件物品之后背包还没装满,则继续选取第i+1件物品,若选该件物品的重量太大不能装入,则放弃而继续选取下一件,直至背包装满为止。但是如果在剩余物品中找不到合适的物品以填满背包,则说明“刚刚”装入背包的那件物品“不合适”,应该将它取出,再继续从它之后的物品中选取,如此重复,直至求得满足要求的解,或者无解为止。因为回溯的规则也是“后进先出”,所以采用栈这个数据结构。
/**
* 利用栈实现的回溯法
* @param data 物品重量
* @param value 背包的称重量
*/
private static void novalue(int[] data, int value){
//利用栈实现回溯
Stack<Integer> stack = new Stack<>();
//物品的数量
int n = data.length;
int k = 0;
do{
while (value > 0 && k < n){
//栈中保存数组的下标
stack.push(k);
//更新value的值
value -= data[k];
k++;
}
if (value == 0){
stack.forEach((index)-> System.out.print(data[index]+" "));
System.out.println();
}
//取得栈顶元素
k = stack.peek();
value += data[k];
stack.pop();
//从下一个数开始判断
k++;
}while (!(stack.isEmpty()&&k==n));
}
相似问题:给定一个仅包含正整数的非空数组,确定该数组是否可以分成两部分,要求两部分的和相等
思路:求数组元素的和sum,在数组中找到和为sum/2的数组子集,则剩下的数组元素和也为sum/2,如果sum%2不为0,直接放回false。
(2)经典的0-1背包问题(有物品的价值):
给定n种物品和一个背包。物品i的重量是wi,其价值为vi,背包的容量为C。应该如何选择装入背包中的物品,使得装入背包中物品的总价值最大?
上面的两个问题都是0-1背包问题,因为隐含的信息是:对每种物品只有两种选择,即装入背包或者不装入背包。不能将物品装入多次,也不能只装入部分的物品。
解题思路:
其实可以采用问题(1)的解法,因为要使价值最大化,肯定也是尽可能多的往背包里装物品。只是此时不要求装满背包,而是在过程中不断比较每种情况的总价值,并找到总价值最大的选择方式。
/**
* @param data 物品的重量
* @param cost 物品的价值
* @param value 背包的承重量
*/
@SuppressWarnings("unchecked")
public static void solution(int [] data,int [] cost,int value){
Stack<Integer> stack = new Stack<>();
//纪录最大价值栈
Stack<Integer> result = new Stack<>();
int k = 0;
int tempMaxValue = 0;
int maxValue = Integer.MIN_VALUE;
do {
while (value > 0 && k < data.length){
stack.push(k);
value -= data[k];
tempMaxValue += cost[k];
k ++;
}
if (value == 0 && tempMaxValue > maxValue){
//记录最大值
maxValue = tempMaxValue;
result = (Stack<Integer>) stack.clone();
}
//回溯
k = stack.pop();
value += data[k];
tempMaxValue -= cost[k];
if (tempMaxValue > maxValue){
maxValue = tempMaxValue;
result = (Stack<Integer>) stack.clone();
}
k ++;
}while (!stack.isEmpty()||k<data.length);
//输出结果
System.out.println("最大值:"+maxValue);
result.forEach((v)->{
System.out.print(data[v]+" ");
});
}
(3)完全背包, 每个物品可以取无限次.
这种背包问题可以用贪心算法求解,先计算每种物品单位重量的价值vi/wi;然后根据贪心策略,将可能多得单位重量价值最高的物品装入背包;依次使用这种策略,直至装满背包为止。
/**
* 完全背包问题
* 这种背包问题可以用贪心算法求解,先计算每种物品单位重量的价值vi/wi;然后根据贪心策略,将可能多得单位重量价值最高的物品装入背包;
* 依次使用这种策略,直至装满背包为止。
* @param data 物品重量
* @param value 背包承重量
* @param cost 物品价值
*/
private static void numberNoLimit(int [] data ,int value,int []cost){
double[] unit = new double[data.length];
//记录是否已经装入背包,以便找到下一个最大值
boolean [] isPack = new boolean[data.length];
for (int i = 0 ; i < data.length;i++){
//这里乘以1.0解决类型转换问题
unit[i] = cost[i]*1.0/data[i];
}
double maxUnit;
int maxUnitIndex = -1;
int maxCost = 0;
while (value > 0) {
maxUnit = -1;
//找到最大的单位价值物品的下标
for (int j = 0; j < data.length; j++) {
if (!isPack[j] && (unit[j] > maxUnit)) {
maxUnit = unit[j];
maxUnitIndex = j;
}
}
isPack[maxUnitIndex] = true;
//尽量将此物品装入背包
while (value >= data[maxUnitIndex]){
maxCost += cost[maxUnitIndex];
//更新价值
value -= data[maxUnitIndex];
}
}
System.out.println("最大价值为:"+maxCost);
}
(4)多重背包
多重背包问题限定了一种物品的个数,解决多重背包问题,只需要把它转化为0-1背包问题即可。比如,有2件价值为5,重量为2的同一物品,我们就可以分为物品a和物品b,a和b的价值都为5,重量都为2,但我们把它们视作不同的物品。
/**
* 多重背包问题限定了一种物品的个数,解决多重背包问题,只需要把它转化为0-1背包问题即可。比如,有2件价值为5,重量为2的同一物品,
* 我们就可以分为物品a和物品b,a和b的价值都为5,重量都为2,但我们把它们视作不同的物品。
* @param data 物品的重量
* @param value 背包的承重量
* @param cost 物品的价值
* @param number 物品的个数
*/
private static void numberLimit(int [] data,int value,int [] cost,int [] number){
//总物品数
int sum = 0;
for (int n:number){
sum += n;
}
int [] dataNew = new int[sum];
int [] valueNew = new int[sum];
int start = 0;
//重新构建物品重量,价值数组
for (int r = 0 ; r < number.length;r++){
for (int s = start;s < start+number[r]; s++){
dataNew[s] = data[r];
valueNew[s] = cost[r];
}
start += number[r];
}
for (int aDataNew : dataNew) {
System.out.print(aDataNew + " ");
}
System.out.println();
for (int aValueNew : valueNew) {
System.out.print(aValueNew+ " ");
}
//利用0-1背包问题解决
valueLimit(dataNew,value,valueNew);
}
背包问题的动态规划解法详解
背包问题是动态规划类求解的一个典型问题,我们要先找到该问题的局部解然后扩展到全局解。这里讲解的是0-1背包。先看一下情景,假如一个小偷携带者一个可以放10kg重的背包,潜入一户人家行窃,家里有4个物品,每个物品只有1个。即价值v[] = {10, 40, 30, 50},重量w[] = {5, 4, 6, 3}。如果超出这个重量背包就会断,就没法带出,但是家里面有很多物品,他们对应着不同的重量和不同的价值,有的可能很轻但价值很高(比如珠宝),有的很重但价值不高,要在背包重量有限的情况下收益最大,这种问题直接看和思考,在数量不多的情况下可以找到最佳的组合,但是代码该如何实现呢?先构建一个二维数组V[N][W],行代表当前重量,列代表前?个物品,填充的数值即此时的价值,而且是当前情况下的最大价值。
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
item0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
item1 | 0 |
|
|
|
|
|
|
|
|
|
|
item2 | 0 |
|
|
|
|
|
|
|
|
|
|
item3 | 0 |
|
|
|
|
|
|
|
|
|
|
item4 | 0 |
|
|
|
|
|
|
|
|
|
|
如表,此时行列均为0,即第0列代表重量为0时的情况,第0行代表放0个物品的时候的情况。然后我们从第1行开始继续填值,第一行代表前1个物品的情况,也就是只有第一个物品,第一个物品重5,则当前背包容量>=5时候才能放入,即第1行第1,2,3,4列价值均为0,因为此时背包无法容纳物品1。而第6列时,除了物品1还剩余1kg,但是此时是第1列,只考虑前1个物品,因此没有其余物品能放入,后面均为10。
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
item0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
item1 | 0 | 0 | 0 | 0 | 0 | 10 | 10 | 10 | 10 | 10 | 10 |
item2 | 0 |
|
|
|
|
|
|
|
|
|
|
item3 | 0 |
|
|
|
|
|
|
|
|
|
|
item4 | 0 |
|
|
|
|
|
|
|
|
|
|
按照这种规则继续放入第2行,此时有2个物品,重量分别为5和4,价值为10和40,在第2行的第1,2,3列中,背包容量小于这2个物品,因此无法放入,价值为0。在第4列中,出现问题了,我们现在多了一个重量为4的物品,可以放入,但是到底该不该放入呢?这时候就是解决问题的关键,我们要考虑局部最优解,在背包为4的时候,如果放入,价值是40,不放入,那么物品1也放不进去,价值为0,即与他的相同列前一行进行比较,所以这时候需要放入物品2。第5列的时候,代表当前背包能容纳5kg,已放入4kg,另一个物品重5kg,因此在4+5=9kg之前,都只能放入物品2,最大价值为40。第9列时可以放入物品1,此时背包最大价值为当前已放入价值+可容纳剩余容量的价值=50,大于其前一行的最大价值10,因此,填充如下:
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
item0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
item1 | 0 | 0 | 0 | 0 | 0 | 10 | 10 | 10 | 10 | 10 | 10 |
item2 | 0 | 0 | 0 | 0 | 40 | 40 | 40 | 40 | 40 | 50 | 50 |
item3 | 0 |
|
|
|
|
|
|
|
|
|
|
item4 | 0 |
|
|
|
|
|
|
|
|
|
|
依次类推,可补充完全如下,注意第3行第9列与第10列,第9列情形和上一行类似,此时有3个物品,但是在背包容量为9时,只能放入物品1(5kg)和物品2(4kg),这就是此时的最优解。但是第10列时,此时背包容量为10,在没有物品3的时候最优解是50,可是此时,最优解是物品2和物品3放入,因为他们的价值大于50,因此第10列为70。
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
item0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
item1 | 0 | 0 | 0 | 0 | 0 | 10 | 10 | 10 | 10 | 10 | 10 |
item2 | 0 | 0 | 0 | 0 | 40 | 40 | 40 | 40 | 40 | 50 | 50 |
item3 | 0 | 0 | 0 | 0 | 40 | 40 | 40 | 40 | 40 | 50 | 70 |
item4 | 0 | 0 | 0 | 50 | 50 | 50 | 50 | 90 | 90 | 90 | 90 |
第4行第10列即我们想要的全局最优解,此时将局部扩大到全部。返回它即得到最优解。
背包问题解法模板(Java实现)
简单背包:
package beibao;
import java.util.Scanner;
/*
* 有n件物品和容量为m的背包 给出i件物品的重量以及价值 求解让装入背包的物品重量不超过背包容量 且价值最大
特点 但它的特点是每个物品只能选用一次
* */
public class situation01 {
//01背包
public static void main(String args[]){
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();//物品的总数量
int m = scanner.nextInt();//背包的重量
int a[] = new int[50001];//重量
int b[] = new int[50001];//价值
for (int i=1;i<=n;i++){
a[i] = scanner.nextInt();
b[i] = scanner.nextInt();
}
int f[] = new int[50001];
for (int i=1; i<=n; i++){
for (int j=m; j>=a[i]; j--){//完全背包只修改了这一句的顺序,其余不变for(int j=a[i]; j<=m; j++)
if (f[j-a[i]]+b[i]>f[j])//多重背包就是在a[i]和b[i]前面加了数量
f[j] = f[j-a[i]]+b[i];
}
}
System.out.println(f[m]);
}
}
完全背包:
package beibao;
import java.util.Scanner;
/*
* 有n件物品和容量为m的背包 给出i件物品的重量以及价值 求解让装入背包的物品重量不超过背包容量 且价值最大
特点 题干看似与01一样 但它的特点是每个物品可以无限选用
* */
public class situation02 {
public static void main(String args[]){
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();//物品的数量
int m = scanner.nextInt();//背包的重量
int a[] = new int[50001];
int b[] = new int[50001];
for (int i=1;i<=n;i++){
a[i] = scanner.nextInt();
b[i] = scanner.nextInt();
}
int f[] = new int[50001];
for (int i=1; i<=n; i++){
for (int j=a[i]; j<=m; j++){//完全背包只修改了这一句的顺序,其余不变for(int j=a[i]; j<=m; j++)
if (f[j-a[i]]+b[i]>f[j])
f[j] = f[j-a[i]]+b[i];
}
}
System.out.println(f[m]);
}
}
多重背包:
package beibao;
import java.util.Scanner;
import static sun.swing.MenuItemLayoutHelper.max;
public class situation03 {
/*
* 多重背包
* 每件物品可以选择有限的次数
* */
public static void main(String args[]){
Scanner scanner = new Scanner(System.in);
int m = scanner.nextInt();//背包的重量
int n = scanner.nextInt();//物品的总数量
int[] a = new int[10001];//重量
int[] b = new int[10001];//价值
int[] c = new int[10001];//数量
for (int i=0; i<n; i++){
a[i] = scanner.nextInt();
b[i] = scanner.nextInt();
c[i] = scanner.nextInt();
}
int f[] = new int[10001];
for (int i=1; i<=n; i++){
for (int j=m; j>=0; j--){
for (int k=0; k<=c[i]; k++){
if (j-k*a[i]<0) break;
f[j]= max(f[j],f[j-k*a[i]]+k*b[i]);
}
}
}
System.out.println(f[m]);
}
}