0,1 背包
有N件物品和一个容量是V的背包。每件物品有且只有一件。
第 i 件物品的体积是v[i] ,价值是 w[i] 。
这类问题就是背包里的物体每次只能选一次,是比较简单的
class Solution {
public int maxValue(int N, int C, int[] v, int[] w) {
int[] dp = new int[C + 1];
for (int i = 0; i < N; i++) {
for (int j = C; j >= v[i]; j--) {
// 不选该物品
int n = dp[j];
// 选择该物品
int y = dp[j-v[i]] + w[i];
dp[j] = Math.max(n, y);
}
}
return dp[C];
}
}
无限选择背包
有N种物品和一个容量为 V 的背包,每种物品都有无限件。
第 i件物品的体积是v[i] ,价值是 w[i]。
class Solution {
public int maxValue(int N, int C, int[] v, int[] w) {
int[] dp = new int[C + 1];
for (int i = 0; i < N; i++) {
for (int j = 0; j <= C; j++) {
// 不考虑第 i 件物品的情况(选择 0 件物品 i)
int n = dp[j];
// 考虑第 i 件物品的情况
int y = j - v[i] >= 0 ? dp[j - v[i]] + w[i] : 0;
dp[j] = Math.max(n, y);
}
}
return dp[C];
}
}
多重背包
有N种物品和一个容量为 V 的背包,每种物品都有s[i]。
第 i件物品的体积是v[i] ,价值是 w[i]。
二进制优化
所谓二进制优化,就是把他的状态进行压缩。
比如: 数量为7 ,我们表示的话,就要用7个1 来表示 , 但如果用到了优化,可以用1,2,4来替换表达。
class Solution {
public int maxValue(int N, int C, int[] s, int[] v, int[] w) {
// 扁平化
List<Integer> worth = new ArrayList<>();
List<Integer> volume = new ArrayList<>();
// 我们希望每件物品都进行扁平化,所以首先遍历所有的物品
for (int i = 0; i < N; i++) {
// 获取每件物品的出现次数
int val = s[i];
// 进行扁平化:如果一件物品规定的使用次数为 7 次,我们将其扁平化为三件物品:1*重量&1*价值、2*重量&2*价值、4*重量&4*价值
// 三件物品都不选对应了我们使用该物品 0 次的情况、只选择第一件扁平物品对应使用该物品 1 次的情况、只选择第二件扁平物品对应使用该物品 2 次的情况,只选择第一件和第二件扁平物品对应了使用该物品 3 次的情况 ...
for (int k = 1; k <= val; k *= 2) { // 最重要部分
val -= k;
worth.add(w[i] * k);
volume.add(v[i] * k);
}
if (val > 0) {
worth.add(w[i] * val);
volume.add(v[i] * val);
}
}
// 0-1 背包问题解决方案
int[] dp = new int[C + 1];
for (int i = 0; i < worth.size(); i++) {
for (int j = C; j >= volume.get(i); j--) {
dp[j] = Math.max(dp[j], dp[j - volume.get(i)] + worth.get(i));
}
}
return dp[C];
}
}
单调队列优化
所谓单调队列优化,想法是这样子的:
对于第n件物品,我们已经知道了前n-1 件物品的最值情况,于是有我们就可以找出前面中最好的情况,对于一个 v[n] *k + b 的体积, 它只能是 v[n]*(k-1)+b , v[n]*(k-2)+b ...... v[n]*0+b变化而来,于是我们就要找出最合适的情况 , 于是就把他们都加到体积为v[n]*k+b ,看看谁的价格最好。为了使它的时间复杂读降低,我们就需要使用队列来(对于队列可以看我的这篇博客队列求最大值,最小值),找到最大值。
class Solution {
public int maxValue(int N, int C, int[] s, int[] v, int[] w) {
int[] dp = new int[C + 1];
int[] g = new int[C + 1]; // 辅助队列,记录的是上一次的结果
int[] q = new int[C + 1]; // 主队列,记录的是本次的结果
// 枚举物品
for (int i = 0; i < N; i++) {
int vi = v[i];
int wi = w[i];
int si = s[i];
// 将上次算的结果存入辅助数组中
g = dp.clone();
// 枚举余数
for (int j = 0; j < vi; j++) {
// 初始化队列,head 和 tail 分别指向队列头部和尾部
int head = 0, tail = -1;
// 枚举同一余数情况下,有多少种方案。
// 例如余数为 1 的情况下有:1、vi + 1、2 * vi + 1、3 * vi + 1 ...
for (int k = j; k <= C; k+=vi) {
dp[k] = g[k];
// 将不在窗口范围内的值弹出
if (head <= tail && q[head] < k - si * vi) head++;
// 如果队列中存在元素,直接使用队头来更新
if (head <= tail) dp[k] = Math.max(dp[k], g[q[head]] + (k - q[head]) / vi * wi);
// 当前值比对尾值更优,队尾元素没有存在必要,队尾出队
while (head <= tail && g[q[tail]] - (q[tail] - j) / vi * wi <= g[k] - (k - j) / vi * wi) tail--;
// 将新下标入队
q[++tail] = k;
}
}
}
return dp[C];
}
}