三种背包概念
01背包(ZeroOnePack): 有N件物品和一个容量为V的背包。每种物品均只有一件。第i件物品的费用是c[i],价值是w[i]。求解将哪些物品装入背包可使价值总和最大。
完全背包(CompletePack): 有N种物品和一个容量为V的背包,每种物品都有无限件可用。第i种物品的费用是c[i],价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量,且价值总和最大。
多重背包(MultiplePack): 有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用,每件费用是c[i],价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量,且价值总和最大。
这三种背包问题的区别在于:01背包是只能每种物品只有一件可以拿,完全背包每种物品可以拿无数次,多重背包每种物品可以拿有限次。
模板
- 01背包
背包容量:V
物品种类:N
物品所占空间(费用):c[N]
物品价值:w[i]
这里设置dp[i][v]
为对于前面i件商品放入容量为v的背包中能获得的最大价值。对于第i件商品,有两种情况,即取第i件商品或不取。对于取商品,dp[i][v]=dp[i-1][v-c[i]]+w[i]
,表示当前的最大价值等于前面第i-1件物品放入容量为v-c[i]的背包中能获得的最大价值加上当前物品的价值;而对于不取商品,dp[i][v]=dp[i-1][v]
,即当前最大价值等于取前面第i-1件商品放入容量为v的背包中。
状态转移方程如下:
dp[i][V] = Math.max(dp[i-1][V],dp[i-1][v-c[i]]+w[i]);
为了简化上述转移方法,在循环时以物品种类为外圈,以背包容量为内圈,从V遍历到0,简化为:
dp[V] = Math.max(dp[V],dp[v-c[i]]+w[i]);
模板如下:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int N = sc.nextInt(); //物品个数
int V = sc.nextInt(); //背包容量
int[] c = new int[N]; //每个商品的花费(所占容量)
int[] w = new int[N]; //每个商品的价值
for (int i = 0; i < N; i++) {
c[i] = sc.nextInt();
w[i] = sc.nextInt();
}
int[] dp = new int[V + 1];
for (int i = 0; i < N; i++) {
for (int j = V; j >= 1; j--) {
if (c[i] <= j) {
dp[j] = Math.max(dp[j], dp[j - c[i]] + w[i]);
}
}
}
System.out.println(dp[V]);
}
}
}
- 完全背包
背包容量:V
物品种类:N
物品所占空间(费用):c[N]
物品价值:w[i]
这种题的特点是一个物品可以拿无数次。这里假设当前物品i拿了k次,k的范围为:0 <= k * c[i] <= v,这里的0表示不拿。
动态转移方程如下:
dp[i][v] = Math.max(dp[i-1][v-k*c[i]]+k*w[i]) ,其中0 <= k * c[i] <= v
转换为一维数组为:注意这里和01背包的区别是内循环为顺序
for i : 0...N
for j : 1...V
dp[v] = Math.max(dp[v],dp[v-c[i]]+w[i]) ,其中0 <= k * c[i] <= v
模板如下:
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int N = sc.nextInt(); //物品个数
int V = sc.nextInt(); //背包容量
int[] c = new int[N]; //每个商品的花费(所占容量)
int[] w = new int[N]; //每个商品的价值
for (int i = 0; i < N; i++) {
c[i] = sc.nextInt();
w[i] = sc.nextInt();
}
int[] dp = new int[V + 1];
for (int i = 0; i < N; i++) {
for (int j = 1; j <= V; j++) {
if (c[i] <= j) {
dp[j] = Math.max(dp[j], dp[j - c[i]] + w[i]);
}
}
}
System.out.println(dp[V]);
}
}
}
- 多重背包
有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用,每件费用是c[i],价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量,且价值总和最大。
其状态转移方程和完全背包类似,因为第i种物品有n[i]件,所以一共了n[i]+1种策略,即取0件、1件…n[j]件,状态转移方程如下:
dp[i][v] = Math.max(dp[i-1][v-k*c[i]]+k*w[i]) (0 <= k <= n[i])
初始化条件为:
dp[i][0] = 0;
dp[0][v] = 0
背包容量:V
物品种类:N
设定一个类储存物品:Goods
物品数组:goods[]
class Goods{
private int count;//物品的个数
private int cost;//物品的花费
private int worth;//物品的价值
}
一共三层循环:
for i 0 ... N
for j 1....V
for k 0...goods[i].count
dp[i][j] = Math.max(dp[i][j],dp[i-1][v-k*goods[i].cost]+k*goods[i].worth);
模板如下:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int N = sc.nextInt(); //物品个数
int V = sc.nextInt(); //背包容量
Goods[] goods = new Goods[N];
for (int i = 0; i < N; i++) {
goods[i] = new Goods(sc.nextInt(), sc.nextInt(), sc.nextInt());
}
int[][] dp = new int[N][V + 1];
for (int i = 0; i < N; i++) {
for (int j = 1; j <= V; j++) {
for (int k = 0; k < goods[i].getCount(); k++) {
dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - k * goods[i].getCost()] + k * goods[i].getWorth());
}
}
}
System.out.println(dp[N - 1][V]);
}
}
}