OI退役笔记-008：基础算法（二）背包问题（背包九讲）

〇、关于背包

背包问题是信息学竞赛里一类重要的问题。

背包问题(Knapsack problem)是一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。问题的名称来源于如何选择最合适的物品放置于给定背包中。相似问题经常出现在商业、组合数学，计算复杂性理论、密码学和应用数学等领域中。也可以将背包问题描述为决定性问题，即在总重量不超过W的前提下，总价值是否能达到V？（百度百科）

一、0-1 背包

基本思路：可以用二维数组 f[i][j]表示截至第 i 个物品，放到容量为 j 的背包里的最大收益。

for i = 1 to n
	for j = w to m
		dp[i][j] = max{dp[i - 1][j], dp[i - 1][j - w] + c}

对于该算法，时间上不能再优化，但空间上可以：

for i = 1 to n
	for j = m to w
		dp[j] = max{dp[j], dp[j - w] + c}

其中关键点为逆序
之前的 f[i][j] 需要且只需要关联 f[i - 1][j]，也就是说对于一个 i, i > 2，f[i - 2][…] 的值就是没有用的了。
而如果只用一维数组时，需保证对于当前 i 的状态 f[i][j] 是 上一轮的状态，即 f[i - 1][j]。而逆序（从后往前扫）的作用便是不覆盖还需要使用的上一轮的状态。
*** 详细比较在完全背包后

#include <cstdio>

int w, c, f[10001], m, n;

int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d%d", &w, &c);
		for (int j = m; j >= w; --j)
			f[j] = f[j] > f[j - w] + c ? f[j] : f[j - w] + c;
	}
	printf("%d", f[m]);
}

0-1 背包是众多背包问题的基础。

练习题：

#include <cstdio>
#define max(a, b)   ((a > b) ? a : b)
 
int t, m, v, c, f[1001];
 
int main()
{
    scanf("%d%d", &t, &m);
    for (int i = 1; i <= m; ++i)
    {
        scanf("%d%d", &v, &c);
        for (int j = t; j >= v; --j)
        {
            f[j] = max(f[j], f[j - v] + c);
        }
    }
     
     
    printf("%d", f[t]);
}

#include <cstdio>
#define max(a, b)   ((a > b) ? a : b)
 
int n, t, k, f[1001];
 
int main()
{
    scanf("%d%d", &n, &t);
    f[0] = 1;
    for (int i = 1; i <= n; ++i)
    {
        scanf("%d", &k);
        for (int j = t; j >= k; --j)
        {
            f[j] += f[j - k];
        }
    }
     
    printf("%d", f[t]);
}

二、完全背包

#include <cstdio>

int w, c, f[10001], m, n;

int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d%d", &w, &c);
		for (int j = w; j <= m; ++j)
			f[j] = f[j] > f[j - w] + c ? f[j] : f[j - w] + c;
	}
	printf("%d", f[m]);
}

这个相较于上一题的唯一区别就是换成了顺序扫描。

背包的顺序、逆序问题

参考

逆序扫描可以保证每一个物品只使用一次，而顺序扫描的话每一个物品可能扫描不止一次。而顺逆两种情况恰好符合完全背包、0-1 背包的题意。

三、多重背包

多重背包也可以转换为 0-1 背包问题。其中，数量为 p[i] 的物品可以拆成 p[i] 个小物品。
在此基础上，可以进行更好的优化：二进制优化

对于任意的整数 k，若 2ⁿ <= k < 2ⁿ⁺¹，则用 1、2、4、……、2ⁿ 这 n + 1 个数一定可以凑成 k

#include <cstdio>

int n, m, v[501], w[501], s[501], f[6001];

inline void dp(int x, int y){
    for (int i = m; i >= x; i--)
		f[i] = max(f[i], f[i - x] + y);
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
		scanf("%d%d%d", &v[i], &w[i], &s[i]);
    
	for(int i = 1; i <= n; i++){
        int k = 1;
        while (s[i] > k){
            s[i] -= k;
            dp(k * v[i], k * w[i]);
            k *= 2;
        }
        dp(s[i] * v[i],s[i] * w[i]);
    }
    
    printf("%d", f[m]);
}

四、混合背包

背包的一大特点是算法可以混合。针对此类问题，可将其拆分为前面所述三种背包问题。

// 自己写的码格式不太好看，贴一下别人的🐎
#include<cstdio>
#define max(a,b) ((a>b)?a:b)
using namespace std;
int n, m, s[600], v[1500], p[1500], dp[7000];
 
int main(){
    scanf("%d%d",&m,&n);
    for(int i = 1;i <= n;i++) scanf("%d%d%d",&v[i],&p[i],&s[i]);
    for(int i = 1;i <= n;i++)
    {
        if(s[i] == 0)
        {
            for(int j = v[i];j <= m;j++)
            {
                dp[j] = max(dp[j],dp[j-v[i]]+p[i]);
            }
        }
        else
        {
            for(int j = 1;s[i];j <<= 1)
            {
                if(s[i] <= j) j = s[i];
                for(int k = m;k >= v[i]*j;k--)
                {
                    dp[k] = max(dp[k],dp[k-v[i]*j]+p[i]*j);
                }
                s[i] -= j;
            }
        }
    }
    printf("%d",dp[m]);
}

五、二维费用背包

背包是可以叠加的，针对二位费用背包只需要添加一维度。
同样地转为 0-1 背包

for (int i = 1; i <= n; ++i)
    for (int j = V; j >= w; --j)
        for (int k = T; k >= g; --k)
            f[j][k] = max(f[j][k], f[j - w][k - g] + v);

#include <cstdio>
#define max(a, b)   ((a > b) ? a : b)
 
int n, m, k, c[101], r[101], f[501][1001];
 
int main()
{
    scanf("%d%d%d", &n, &m, &k);
    for (int i = 1; i <= k; ++i)
        scanf("%d%d", &c[i], &r[i]);
     
    for (int i = 1; i <= k; ++i)
        for (int j = m; j >= r[i]; --j)
            for (int p = n; p >= c[i]; --p)
                f[j][p] = max(f[j][p], f[j - r[i]][p - c[i]] + 1);
     
    int k;
    // i 一定要从 1 开始！！！
    // 从 0 开始的话会出错，我至今搞不懂为什么 f[0][0] 有时会等于 f[m][n]
    for (int i = 1; i <= m; i++)
        if (f[i][n] == f[m][n])
        {k = i; break;}
             
 
    printf("%d %d", f[m][n], m - k);
}

背包的不小于问题

（输入样例的答案是249）
典型的二维费用背包，但是题目竟然是不小于

#include <cstdio>
#include <cstring>
#define min(a, b)	((a < b) ? a : b)
#define max(a, b)	((a > b) ? a : b)

int dp[30][80];
int n, m, k, t, a, w;
 
int main()
{
    scanf("%d%d%d", &n, &m, &k);
 
    memset(dp, 0x3f, sizeof dp);
    dp[0][0] = 0;
    for (int i = 1; i <= k; ++i)
    {
        scanf("%d%d%d", &t, &a, &w);
        for (int j = n; j >= 0; --j)
        {
            for (int z = m; z >= 0; --z)
            {
				dp[j][z] = min(dp[j][z], dp[max(0, j - t)][max(0, z - a)] + w);
            }
        }
    }
     
    printf("%d", dp[n][m]);  
}

原来的背包是求不大于用 max，此处不小于即可换成 min。

背包的等于问题

#include <cstdio>
 
long long v, n, k, f[int(1e5+1)];
 
int main()
{
    scanf("%lld%lld", &v, &n);
    f[0] = 1;
    for (int i = 1; i <= v; ++i)
    {
        scanf("%lld", &k);
        for (int j = 0; j <= n; ++j)
        {
            if (j >= k)
                f[j] += f[j - k];
        }
    }
     
     
    printf("%lld", f[n]);
}

等于问题只需要增加，不需要判断最大值、最小值。

总结：
最大值问题：f[j] = max{f[j], f[j - v]}
不小于问题：f[j] = min{f[j], f[j - v]}
等 于 问 题：f[j] += f[j - v]

多维费用背包问题

一道题的费用为 n 维，则需要开 n 维数组，进行 n 维循环。
核心思想都是化为 0-1 数组。

六、分组背包

分组背包是指有 n 组物品，每组只能选用一个，问最大收益。
该问题需要先循环组数，再循环体积，后循环每组中的个数。

理由：因为每组只能选一个，即可化为一个较简单的问题：每组的物品是取还是不取。因此，通过二维数组表示状态，即：

f[k][j] = max(f[k − 1][j], f[k − 1][j − c[i]] + w[i]
// 物品 i 属于组 k

再转换为 0-1 背包：

#include <cstdio>
#define max(a, b)   ((a > b) ? a : b)
 
int v, n, t, w[11][32], c[11][32], f[201];
 
int main()
{
    scanf("%d%d%d", &v, &n, &t);
    for (int a, b, d, i = 1; i <= n; ++i)
    {
        scanf("%d%d%d", &a, &b, &d);
        w[d][++w[d][31]] = a;
        c[d][++c[d][31]] = b;
    }
     
    for (int g = 1; g <= t; ++g)
    {
        for (int j = v; j >= 0; --j)
        {
            for (int i = 1; i <= w[g][31]; ++i)
            {
            	// 因为要先循环体积，所以要特判一下当前状态体积是否小于当前物品体积
                if (j >= w[g][i])
                    f[j] = max(f[j], f[j - w[g][i]] + c[g][i]);
            }
        }
    }
     
    printf("%d", f[v]);
}

作者：Rotch
日期：2020-11-24
修改：2020-11-24