背包DP全类型
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010;
int n, m;
int v[N], w[N];
int f[N];
int main()
{
cin >> n >> m;
for(int i = 1; i <= n; i++) cin >> v[i] >> w[i];
for(int i = 1; i <= n; i++)
{
for(int j = m; j >= v[i]; j--)
{
f[j] = max(f[j], f[j-v[i]] + w[i]);
}
}
cout << f[m] << endl;
return 0;
}
状态表示：\(f(i，j)\) 其中的\(i\)表示只从前\(i\)种物品选，\(j\)表示选出来的物品总体积 \(\leq\) j，因此\(f(i，j)\)就表示从前\(i\)种物品中选出总体积不超过\(j\)的所有选法。
状态计算：集合划分
第\(i\)种物品选\(0\)，\(1\)，\(2\)，\(3\)，\(……\)，\(k-1\)，\(k\)个。
如果第\(i\)种物品，一个也不选，则说明我们只考虑前\(i-1\)种物品，即：\(f(i-1, j)\)
如果选第\(i\)种物品选\(k\)个，则我们可以采取与\(01\)背包类似的思路，去掉已经确定了价值的\(k\)个第\(i\)种物品，因为这并不会影响前\(i-1\)种物品我们选法的最大价值，因此得到方程：
这里注意，第\(i\)种物品如果我们不选的话，就等价于\(f(i-1, j)\)，因此不选的情况我们也可以并到上式子中，因此我们得到状态转移方程：
再进行优化：
将式子展开：
而：
观察上下两式，我们看出式子\(1\)后 \(f(i-1, j-v) + w, f(i-1, j-2*v) + 2*w, f(i-1, j-3*v) + 3*w, ...\)可以由式子\(2\):\(f(i, j-v)\) \(+\) \(w\)得到,于是我们就可以进行合并，我们可以得到这样的式子：
因此这样就可以不用再枚举\(k\)了，只需要枚举两个状态即可。
\(f(i, j) = max(f(i-1, j), f(i, j-v) + w)\)与\(01\)背包的状态转移方程并不同，\(01\)背包需要从\(i-1\)转移而来，而完全背包是从\(i\)转移而来。
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010;
int n, m;
int f[N], w[N], v[N];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> v[i] >> w[i];
}
for (int i = 1; i <= n; i++) {
for (int j = v[i]; j <= m; j++) {
f[j] = max(f[j], f[j - v[i]] + w[i]);
}
}
cout << f[m] << endl;
return 0;
}
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 110;
int n, m;
int f[N][N];
int v[N], w[N], s[N];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> v[i] >> w[i] >> s[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= m; j++) {
for (int k = 0; k <= s[i] && k * v[i] <= j; k++) {
f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + k * w[i]);
}
}
}
cout << f[n][m] << endl;
return 0;
}
二进制优化
这个如果再用朴素做法就不行了，\(O(NVS)\) 大约要\(4*10^9\)，肯定不行，而若我们对\(S\)进行二进制拆开然后将整个问题当成\(01\)背包来做，那么复杂度就被有优化为了\(O(NVlogS)\) 大约为\(2*10^7\)，优化了两个数量级。
那为什么我们不用优化完全背包的方法来优化多重背包呢？先从状态转移方程出发
而：
可见\(2\)式比\(1\)式多了一项，因此不能这样优化。
进入二进制优化正题：
假设有件物品的数量为\(200\)，那么我们可以分成\(1， 2， 4， 8， 16， 32， 64\)这么几组，还剩下一个\(73\)不再拆分，分成的每一组我们最多只能拿一次那么就可以按照\(01\)背包做了。
那会出现什么问题吗，例如我们想拿3件但是并没有啊，这问题并不会出现，\(1 + 2 = 3\)啊, 对于例子，\(1，2\)可以凑出\(1-3\)的任何一个数字，同理\(1, 2\)加一个4就可以凑出\(1-7\)任何一个数字，再同理，假设我们可以把\(n\)分出一组\(1, 2, ..., 2^k, C\)，\(C\)不足以\(2^{k+1}\)，否则我们就是\(1, 2, ..., 2^k, 2^{k+1}\)，我们可以用\(1, 2, ..., 2^k\)凑出\(2^{k+1} - 1\)(根据等差数列求和)中的任何一个数字，那么再加一个\(C\)就可以凑出\(1-n\)中任何一个数。那么这样再做一遍\(01\)背包即可，复杂度就由\(O(NVS)\)优化到了\(O(NVlogS)\)。
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 12000;
int v[N], w[N];
int n, m, f[N];
int main() {
cin >> n >> m;
int cnt = 0;
for (int i = 1; i <= n; i++) {
int a, b, s;
cin >> a >> b >> s;
int k = 1;
while (k <= s) {
cnt++;
v[cnt] = a * k, w[cnt] = b * k; //每个物品a 价值为b
s -= k;
k *= 2;
}
if (s > 0) {
cnt++;
v[cnt] = a * s, w[cnt] = b * s;
}
}
n = cnt;
for (int i = 1; i <= n; i++) {
for (int j = m; j >= v[i]; j--) {
f[j] = max(f[j], f[j - v[i]] + w[i]);
}
}
cout << f[m] << endl;
return 0;
}
AcWing 6. 多重背包问题 III
留个坑 等我学了单调队列DP 再来填。
AcWing 7. 混合背包问题
分开分析即可。
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int f[N];
int n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
int v, w, s;
cin >> v >> w >> s;
if (s == 0) {
for (int j = v; j <= m; j++) f[j] = max(f[j], f[j - v] + w);
} else {
if (s == -1) s = 1;
for (int k = 1; k <= s; k *= 2) {
for (int j = m; j >= k * v; j--) {
f[j] = max(f[j], f[j - k * v] + k * w);
}
s -= k;
}
if (s) {
for (int j = m; j >= s * v; j--) {
f[j] = max(f[j], f[j - s * v] + s * w);
}
}
}
}
cout << f[m] << endl;
return 0;
}
AcWing 8. 二维费用的背包问题
在01背包基础上加了一维。
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 110;
int n, V1, V2;
int f[N][N];
int main() {
cin >> n >> V1 >> V2;
for (int i = 1; i <= n; i++) {
int v1, v2, w;
cin >> v1 >> v2 >> w;
for (int j = V1; j >= v1; j--) {
for (int k = V2; k >= v2; k--) {
f[j][k] = max(f[j][k], f[j - v1][k - v2] + w);
}
}
}
cout << f[V1][V2] << endl;
return 0;
}
#include <iostream>
using namespace std;
const int N = 110;
int s[N], w[N][N], v[N][N];
int n, m, f[N];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> s[i];
for (int j = 0; j < s[i]; j++) {
cin >> v[i][j] >> w[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = m; j >= 0; j--) {
for (int k = 0; k < s[i]; k++) { //枚举有多少个
if (v[i][k] <= j) {
f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);
}
}
}
}
cout << f[m] << endl;
return 0;
}
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 110;
int f[N][N]; //表示从以u根的子树中选，总体积不超过j的最大价值
int h[N], e[N], ne[N], idx;
int n, m;
int v[N], w[N];
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
void dfs(int u) {
for (int i = h[u]; i != -1; i = ne[i]) {
int son = e[i];
dfs(e[i]);
for (int j = m - v[u]; j >= 0; j--) { //左一遍分组背包
for (int k = 0; k <= j; k++) {
f[u][j] = max(f[u][j], f[u][j - k] + f[son][k]);
}
}
}
for (int i = m; i >= v[u]; i--) f[u][i] = f[u][i - v[u]] + w[u]; //选择v[u]
for (int i = 0; i < v[u]; i++) f[u][i] = 0;
}
int main() {
cin >> n >> m;
int root;
memset(h, -1, sizeof h);
for (int i = 1; i <= n; i++) {
int p;
cin >> v[i] >> w[i] >> p;
if (p == -1) root = i;
else add(p, i);
}
dfs(root);
cout << f[root][m] << endl;
return 0;
}
AcWing 11. 背包问题求方案数
类似于最短路的计数问题。
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010, Mod = 1e9 + 7;;
int f[N], cnt[N];
int n, m;
int main() {
cin >> n >> m;
for (int i = 0; i <= m; i++) cnt[i] = 1;
for (int i = 1; i <= n; i++) {
int v, w;
cin >> v >> w;
for (int j = m; j >= v; j--) {
int x = f[j - v] + w;
if (x > f[j]) {
f[j] = x;
cnt[j] = cnt[j - v];
} else if (x == f[j]) {
cnt[j] = (cnt[j - v] + cnt[j]) % Mod;
}
}
}
cout << cnt[m] << endl;
return 0;
}
AcWing 12. 背包问题求具体方案
对于方案的求解，我们可以类似于迷宫求最短路径时候的记录方案。
就是判断一下每一步是从哪一步转移过去的，对于背包来说，f[i][j]可能由两个状态转移过来：
- 如果
f[i][j] == f[i - 1][j]:表示从不选第i个物品转移到了f[i][j]，那么记录转移状态的时候肯定必选第i个物品 - 如果
f[i][j] == f[i - 1][j - v] + w:表示选第i个物品转移到了f[i][j]，那么记录路径的时候肯定必然不能选第i个物品。 - 还有一种特例，
f[i - 1][j] == f[i - 1][j - v] + w表示第i个物品可选可不选都可以转移到f[i][j]，那么此是我们肯定是要选的，因为题目中还要保证字典序最小，所以选上肯定比不选的字典序要小。
综上，能选必选。
还有就是对于我们求转移状态的时候其实是倒着往前求得，类比于迷宫，而我们要获得字典序最小需要从前往后求，那么我们解决办法就是再求f的时候直接从n到i枚举即可。
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1010;
int n, m;
int f[N][N];
int v[N], w[N];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> v[i] >> w[i];
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= m; j++) {
f[i][j] = f[i + 1][j];
if (j >= v[i]) {
f[i][j] = max(f[i][j], f[i + 1][j - v[i]] + w[i]);
}
}
}
int j = m;
for (int i = 1; i <= n; i++) {
if (j >= v[i] && f[i][j] == f[i + 1][j - v[i]] + w[i]) {
cout << i << " ";
j -= v[i];
}
}
return 0;
}
关于记录方案还有另外一种方式：
这种转移方法是来自迷宫求最短路的记录方案的灵感，这个题里y总只是提了一下，没有具体讲。
开一个PII g[i][j]数组来记录，表示first表示(i, j)是由first这个点转移而来，second表示由first转移而来的时候第first物品是否被选.
g[i][j] = {i + 1, false}:表示(i，j)这个状态是从没选第i + 1个物品转移而来。
g[i][j] = {i + 1, true}:表示(i，j)这个状态是从选第i + 1个物品转移而来。
然后边DP边记录即可。
对于输出的过程：首先要判断一下g[i][j].second是否为true如果为true，那么表示是由选择一个物品转移而来，那么当前体积需要跟着变化，那就是减去当前的v,反之如果为false，那么就不必减去当前的v，还有注意这两种情况下i都需要进行转移。
还要注意的就是求解的时候还是要倒序求，因为需要保证字典序最小，又因为这个WA了一发。
int i = 1, j = m;
while (i <= n && j) {
if (g[i][j].second == true) {
int t = i;
cout << i << " ";
i = g[i][j].first;
j -= v[t];
} else {
i = g[i][j].first;
}
}
详细的代码有一些细节都在注释里了：
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
typedef pair<int, bool> PII;
const int N = 1010;
int n, m;
int f[N][N];
int v[N], w[N];
PII g[N][N]; //first表示第几件物品 second表示选没选
vector<int> res;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> v[i] >> w[i];
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= m; j++) {
f[i][j] = f[i + 1][j];
g[i][j] = {i + 1, false};
if (j >= v[i]) {
if (f[i + 1][j - v[i]] + w[i] >= f[i][j]) { //注意这里一定要大于等于，因为为了保证字典序，能选必选
g[i][j] = {i + 1, true};
f[i][j] = f[i + 1][j - v[i]] + w[i];
}
}
}
}
int i = 1, j = m;
while (i <= n && j) { //这里一定是&& 一开始写成了||，调了半个多小时
if (g[i][j].second == true) {
int t = i; //这里一定要临时存一下i，因为下边i接着变成了它的上一个状态，而j要减去的是当前状态的v
cout << i << " ";
i = g[i][j].first;
j -= v[t];
} else {
i = g[i][j].first;
}
}
return 0;
}
