背包九讲——菜鸟九题

注意

默认 f 数组初始化为 0，所以 f[i] 不一定是装满 i 容量的最大价值，如果想让 f[i] 表示装满 i 容量的最大价值，可以初始化 f 数组为负无穷，f[0] = 0

下面的题目都在 acwing 题库前面

01背包

每个物品只有一个，所以滚动数组要倒序遍历，防止一个物品被使用了多次，因为先遍历的物品，每个物品按顺序计算，所以不需要开数组存 v, w

#include<iostream>
using namespace std;
const int N = 1e3 + 10;
int f[N];
int n, m;
int v, w;

int main(){
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; i++){
        scanf("%d%d", &v, &w);
        for(int j = m; j >= v; j--){
            f[j] = max(f[j], f[j - v] + w);
        }
    }
    printf("%d", f[m]);
    return 0;
}

完全背包

每个物品有无限个，所以滚动数组可以顺序遍历，每个物品可以多次使用，因为先遍历的物品，每个物品按顺序计算，所以不需要开数组存 v, w

#include<iostream>
using namespace std;
const int N = 1e3 + 10;
int f[N];
int n, m;
int v, w;

int main(){
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; i++){
        scanf("%d%d", &v,&w);
        for(int j = v; j <= m; j++){
            f[j] = max(f[j], f[j - v] + w);
        }
    }
    printf("%d", f[m]);
    return 0;
}

多重背包

把多重背包转换成有限个 01 背包

O(n ^ 3)

#include<iostream>
using namespace std;
const int N = 110;
int f[N];
int n, m;
int v, w, s;

int main(){
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; i++){
        scanf("%d%d%d", &v, &w, &s);
        for(int j = m; j >= v; j--){
            for(int k = 0; k <= s && j >= k * v; k++){
                f[j] = max(f[j], f[j - k * v] + k * w);
            }
        }
    }
    printf("%d", f[m]);
    return 0;
}

O(n ^ 2 * logn)

把多重背包转换成二进制个 01 背包

#include<iostream>
#include<vector>
using namespace std;
const int N = 2010;
int f[N];
int n, m;
int v, w, s;

struct Good{
    int v, w;
};

int main(){
    scanf("%d%d", &n, &m);
    vector<Good> goods;
    for(int i = 0; i < n; i++){
        scanf("%d%d%d", &v, &w, &s);
        for(int j = 1; j <= s; j *= 2){
            s -= j;
            goods.push_back({j * v, j * w});
        }
        if(s > 0) goods.push_back({s * v, s * w});
    }
    for(auto good : goods){
        for(int j = m; j >= good.v; j--){
            f[j] = max(f[j], f[j - good.v] + good.w);
        }
    }
    printf("%d", f[m]);
    return 0;
}

混合背包

把多重背包转换为 01 背包

#include<iostream>
#include<vector>
using namespace std;
const int N = 1010;
int f[N];
int n, m;
int v, w, s;

struct Good{
    int id;
    int v, w;
};

int main(){
    scanf("%d%d", &n, &m);
    vector<Good> goods;
    for(int i = 0; i < n; i++){
        scanf("%d%d%d", &v, &w, &s);
        if(s == -1) goods.push_back({-1, v, w});
        else if(s == 0) goods.push_back({0, v, w});
        else{
            for(int j = 1; j <= s; j *= 2){
                s -= j;
                goods.push_back({-1, j * v, j * w});
            }
            if(s > 0) goods.push_back({-1, s * v, s * w});
        }
    }
    for(auto good : goods){
        if(good.id == -1){
            for(int j = m; j >= good.v; j--){
                f[j] = max(f[j], f[j - good.v] + good.w);
            }
        }else{
            for(int j = good.v; j <= m; j++){
                f[j] = max(f[j], f[j - good.v] + good.w);
            }
        }
    }
    printf("%d", f[m]);
    return 0;
}

二维费用的背包问题

就是把背包容量这个维度，再加了一维重量，需要再加个循环即可

#include<iostream>
using namespace std;
const int N = 1010;
int f[N][N];
int n, m, z;
int v, h, w;

int main(){
    scanf("%d%d%d", &n, &m, &z);
    for(int i = 0; i < n; i++){
        scanf("%d%d%d", &v, &h, &w);
        for(int j = m; j >= v; j--){
            for(int k = z; k >= h; k--){
                f[j][k] = max(f[j][k], f[j - v][k - h] + w);
            }
        }
    }
    printf("%d", f[m][z]);
    return 0;
}

分组背包

若干组背包，每组背包最多只能选一个，多重背包就是特殊的分组背包，注意 j >= v[k] 不能放在 for 循环里

#include<iostream>
using namespace std;
const int N = 110;
int f[N];
int n, m;
int s, v[N], w[N];

int main(){
    cin>>n>>m;
    for(int i = 0; i < n; i++){
        scanf("%d", &s);
        for(int j = 0; j < s; j++) scanf("%d%d", &v[j], &w[j]);
        for(int j = m; j >= 0; j--){
            for(int k = 0; k < s; k++){
                if(j >= v[k]){
                    f[j] = max(f[j], f[j - v[k]] + w[k]);
                }
            }
        }
    }
    cout<<f[m];
    return 0;
}

有依赖的背包问题

树形 dp 和分组背包，f[i][j]: 以 i 为根节点，体积为 j 的最大价值

#include<iostream>
#include<cstring>
using namespace std;
const int N = 110;
int f[N][N];
int v[N], w[N];
int h[N], e[N], ne[N], idx;
int n, m;

void add(int a, int b){
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx;
    idx++;
}

void dfs(int u){
    for(int i = h[u]; i != -1; i = ne[i]){
        int son = e[i];
        // 先递归到子节点
        dfs(son);
        // 因为选子节点必须选父节点，所有要预留 v[u] 位置
        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]);
            }
        }
    }
    // 处理预留 v[u] 的位置，如果剩下的位置大于 v[u] 那就可以选，否则不能选
    for(int i = m; i >= v[u]; i--) f[u][i] = f[u][i - v[u]] + w[u];
    for(int i = 0; i < v[u]; i++) f[u][i] = 0;
}

int main(){
    memset(h, -1, sizeof(h));
    scanf("%d%d", &n, &m);
    int p, root;
    for(int i = 1; i <= n; i++){
        scanf("%d%d%d", &v[i], &w[i], &p);
        if(p == -1) root = i;
        else add(p, i);
    }
    dfs(root);
    printf("%d", f[root][m]);
    return 0;
}

背包问题求方案数

如果当前体积的价值相同，那就累加，否则就重新赋值

#include<iostream>
using namespace std;
const int N = 1010, mod = 1e9 + 7;
int f[N], sum[N];
int n, m;
int v, w;

int main(){
    scanf("%d%d", &n, &m);
    for(int i = 0; i <= m; i++) sum[i] = 1;
    for(int i = 0; i < n; i++){
        scanf("%d%d", &v, &w);
        for(int j = m; j >= v; j--){
            int t = f[j - v] + w;
            if(t > f[j]){
                f[j] = t;
                sum[j] = sum[j - v];
            }
            else if(t == f[j]) sum[j] = (sum[j] + sum[j - v]) % mod;
        }
    }
    printf("%d", sum[m]);
    return 0;
}

背包问题求具体方案

因为要求字典序最小的方案，所以物品顺序需要倒过来从 n 递推到 1，然后再从 1 倒推回 n 找出路径

#include<iostream>
using namespace std;
const int N = 1010;
int f[N][N], v[N], w[N];
int sp[N];
int n, m;

int main(){
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++) scanf("%d%d", &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 cnt = 0;
    for(int i = 1, j = m; i <= n; i++){
        if(j >= v[i] && f[i][j] == f[i + 1][j - v[i]] + w[i]){
            sp[cnt++] = i;
            j -= v[i];
        }
    }
    for(int i = 0; i < cnt; i++) printf("%d ", sp[i]);
    return 0;
}