背包问题汇总

01背包

#include<iostream>
#include<algorithm>

using namespace std;

const int N = 10010;
int f[N], v[N], w[N]; // f[i][j]: 前i种物品中，空间为j时的最大价值。
int main()
{
    int n, m;
    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];
    
    return 0;
}

 

完全背包

#include<iostream>
#include<algorithm>

using namespace std;

const int N = 10010;
int f[N], v[N], w[N]; // f[i][j]: 前i种物品中，空间为j时的最大价值。
int main()
{
    int n, m;
    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];
    
    return 0;
}

注意： 01背包与完全背包的代码仅在第二维的遍历顺序有差异，这是因为两者状态转移方程的不同：

01背包：f[i][j] = max(f[i-1][j], f[i-1][j-v[i]] + w[i]);

完全背包：f[i][j]= max(f[i-1][j], f[i][j-v[i]]] + w[i]);

可以发现01背包由第i-1行转移而来，完全背包由第i行转移而来。
 

多重背包

二进制优化: 对于可选n次的背包，可将其合并成若干个背包(合并得到背包的组合必须能够表示1-n中的任意一个数)， 这样可用01背包求解。

#include <iostream>
#include <algorithm>

using namespace std;
const int N = 23000;
int f[N], v[N], w[N];

int main()
{
    int n, m;
    cin >> n >> m;

    int cnt = 1, x, y, s;
    for(int i = 1; i <= n; i++)
    {
        cin >> x >> y >> s;
        
        for(int k = 1; k <= s; k *= 2)
        {
            v[cnt] = k*x, w[cnt++] = k*y;
            s -= k;
        }
        
        if(s) v[cnt] = s*x, w[cnt++] = s*y;
    }
    
    for(int i = 1; i < cnt; i++)
        for(int j = m; j >= v[i]; j--)
            f[j] = max(f[j], f[j-v[i]] + w[i]);
            
    cout << f[m];

    return 0;
    
}

 

滑动窗口优化：通过滑动窗口求最大值，时间复杂度O(n*v), 其中n为物品数，v为给定的空间。

f(i,j)=max(f(i−1,j),f(i−1,j−v)+w,⋯,f(i−1,j−sv)+sw)
f(i,j−v)=max(f(i−1,j−v),f(i−1,j−2v)+w,⋯,f(i−1,j−(s+1)v)+sw)

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1010, M = 20010;

int v[N], w[N], s[N];
int dp[M], g[M], qq[M];

int main()
{
    int n, m;
    cin >> n >> m;
    
    for(int i = 1; i <= n; i++) {
        cin >> v[i] >> w[i] >> s[i];
    }
    
    for(int i = 1; i <= n; i++) {
        memcpy(g, dp, sizeof g);
        
        for(int j = 0; j < v[i]; j++) {
            int hh = 0, tt = -1;
            
            for(int k = j; k <= m; k += v[i]) {
                
                if(hh <= tt && k - qq[hh] > s[i] * v[i]) { // 超出窗口
                    hh++;
                }
                while(hh <= tt && g[qq[tt]] + (k - qq[tt]) / v[i] * w[i]  <= g[k]) {
                    tt--;
                }
                qq[++tt] = k;
                if(hh <= tt) dp[k] = g[qq[hh]] + (k - qq[hh]) / v[i] * w[i];
            }
        }
    }
    
    cout << dp[m] << endl;
    return 0;
}

 

分组背包

#include <iostream>

using namespace std;

const int N = 110;
int f[N], v[N][N], w[N][N], cnt[N];
// f[i][j]: 前i组物品中，空间为j时的最大价值。
// v[i][j]:	第i组物品的第j个;  cnt[i]: 第i组的物品个数。

int main()
{
    int n, m;
    cin >> n >> m;

    for(int i = 1; i <= n; i++)
    {
        cin >> cnt[i];
        for(int j = 1; j <= cnt[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 = 1; k <= cnt[i]; k++)
                if(v[i][k] <= j) f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);
    }
    
    cout << f[m];
    return 0;
}

 

混合背包

#include <bits/stdc++.h>

using namespace std;

const int N = 1010;
int dp[N]; // dp[i][j]: 前i类物品体积为j的最大价值

int main()
{
    int n, m;
    cin >> n >> m;
    
    for(int i = 1; i <= n; i++) {
        int v, w, s;
        cin >> v >> w >> s;
        
        // 完全背包
        if(s == 0) {
            for(int j = v; j <= m; j++)
                dp[j] = max(dp[j], dp[j - v] + w);
        } else {
            if(s == -1) { // 将01背包看成特殊的多重背包
                s = 1;
            }
            
            for(int k = 1; k <= s; k *= 2) {
                for(int j = m; j >= k * v ; j--) {
                    dp[j] = max(dp[j], dp[j - k * v] + k * w);
                }
                s -= k;
            }
            if(s) {
                for(int j = m; j >= s * v; j--)
                    dp[j] = max(dp[j], dp[j - s * v] + s * w);
            }
        }
         
    }
    cout << dp[m] << endl;
    return 0;
}

 

有依赖的背包问题

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 110;

int n, m;
int v[N], w[N];
int h[N], e[N], ne[N], idx;
int dp[N][N]; // dp[i][j]: 对于i为根节点的子树，体积为j时的最大价值

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 x = e[i];
        dfs(x);
        
        for(int j = m; j >= v[u]; j--) { // 循环当前体积(必须从大到小循环)
            for(int k = 0; k <= j - v[u]; k++ ) {// 循环用于子树的体积
                dp[u][j] = max(dp[u][j], dp[u][j - k] + dp[x][k]);
            }
        }
        
    }
    // 加上根节点的值
    for(int j = v[u]; j <= m; j++)
        dp[u][j] += w[u];
    
}

int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    
    int root;
    for(int i = 1; i <= n; i++) {
        int p;
        cin >> v[i] >> w[i] >> p;
        if(p != -1) {
            add(p, i);
        } else {
             root = i;
        }
    }
    
    dfs(root);
    cout << dp[root][m] << endl;
    
    return 0;
}