背包五讲之Ⅲ：多重背包问题

有关其他的背包问题👇👇👇
背包五讲合集：0-1背包、完全背包、多重背包、分组背包、二维费用的背包。

---

---

题目描述

有 N 种物品和一个容量是 V 的背包。
第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。
接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000<N,V≤100
0<vi,wi,si≤1000<vi,wi,si≤100

输入样例

4 5
1 2 3
2 4 1
3 4 3
4 5 2

输出样例：

10

---

朴素做法

二维

该问题类似于完全背包或者说就是完全背包的一种特殊形式，一些定义基本都是没变

具体看这篇👉背包五讲之Ⅱ：完全背包问题。

但是注意到这里的条件从每件物品的∞个变为si个，所以不再有转移方程

dp[i][j] = max(dp[i - 1][j], dp[i][j - v[i]] + w[i])

存在。用朴素方法做的话，就老实对于每件物品用k枚举，每次比较并更新的对象都是dp[i][j]，直到k <= s[i] && k * v[i] <= j条件不成立为止。

---

C++代码

#include <iostream>
#include <algorithm>

using namespace std;

int N, V;
int v[110], w[110], s[110];
int dp[110][110];

int main()
{
    cin >> N >> V;
    for (int i = 1; i <= N; i ++ )
        cin >> v[i] >> w[i] >> s[i];
    
    for(int i = 1;i <= N;i ++)
        for (int j = 1;j <= V;j ++){
            for(int k = 0;k <= s[i] && k * v[i] <= j;k ++){
                dp[i][j] = max(dp[i][j], dp[i - 1][j - k * v[i]] + k * w[i]);
            }
        }
    cout << dp[N][V] << endl;
    return 0;
}

---

一维

同样地，利用滚动数组优化空间复杂度降至一维，注意j的循环顺序，其他的基本把dp[i][j]—>f[j]就行。

C++代码

#include <iostream>
#include <algorithm>

using namespace std;

int N, V;
int v[110], w[110], s[110];
int f[110];

int main()
{
    cin >> N >> V;
    for (int i = 1; i <= N; i ++ )
        cin >> v[i] >> w[i] >> s[i];
    
    for(int i = 1;i <= N;i ++)
        for (int j = V;j >= 1;j --){
            for(int k = 0;k <= s[i] && k * v[i] <= j;k ++){
                f[j] = max(f[j], f[j - k * v[i]] + k * w[i]);
            }
        }
    cout << f[V] << endl;
    return 0;
}

但这种朴素做法如果遇到数据量稍微大点的肯定会T掉，所以有下面的优化做法。

---

二进制优化

打包处理

对于每次给定的si个的同种物品，我们可以对其进行 “打包成多个大物品” 操作。从本质上来看，多重背包相较于0-1背包的复杂之处仅仅在于物品数量上的选择不同，多重背包朴素做法的时间复杂度基本是 O(n^3) 的，而0-1背包是 O(n^2) ，所以如果能缩小物品数量选择的差异那么就能将时间复杂度逼近到O(n^2)。

而何为“打包”呢？举个例子，对于给定的第i类物品(v[i],w[i])有9个的大前提下，我们可以从两个角度来看它：

1. 由9个属性均为(v[i],w[i])的相同物品组成了这一类。

2. 先对9进行二进制拆分处理，由于1+2+4+2=9，那9可以由1、2、4、2 (注意最后这个2是9取二进制整后余下来的) 这四个数来构成，它的意义在于，我每次选这类物品时，注定选择的数量是0~9之间的，而刚刚进过二进制拆分的四个数（以及0）可以 恰好地表示这区间的任何一个数 。

   表示法 3：1 + 2；5：1 + 2 + 2；6：2 + 4；7：1 + 2 + 4

   然后这9个第i类物品，对其进行打包，得到4个大物品，属性分别为：

   1 * (v[i],w[i])，2 * (v[i],w[i])，4 * (v[i],w[i])，2 * (v[i],w[i])

这样一来如果最优方案里面会选择这第i类物品，那其选择数量必定是这4个大物品构成的排列组合。此时不再将这4个物品看成是一类物品衍生出的，而是4个 “新的单个物品” ，然后按照0-1背包的模板正常dp做，就可以求出最优解。

---

这样做复杂度降低的原因，还是以上例说明，原本9个同种物品，在i-j的内循环里需要枚举9次来进行max()操作，而二进制优化后化9为4，只需进行4次枚举操作来找出组合方案就达到了目的。换句话说，将n次枚举变为了 ⌈logn⌉ 次枚举，因此复杂度也从 O(n^3) 降到约 O(n^2 * logn) 。

Java代码

import java.util.*;

class Item{     //打包后的大物品
    public int v;
    public int w;
    public Item(int v_, int w_){
        v = v_;
        w = w_;
    }
}

public class Main{
    public static int [] f = new int[2010];     //直接一维优化
    public static int v = 0, w = 0, s = 0;
    public static int N = 0, V = 0;
    public static List<Item> items = new ArrayList<>();     //装大物品
    
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        N = in.nextInt();
        V = in.nextInt();
        for(int i = 1;i <= N;i ++){
            v = in.nextInt();
            w = in.nextInt();
            s = in.nextInt();
            for(int k = 1;k <= s;k *= 2){               //二进制拆分
                s -= k;
                items.add(new Item(k * v, k * w));
            }
            if(s > 0)       items.add(new Item(s * v, s * w));	//取出余下的
        }
        in.close();
        for(var it : items){            //拆分后就视为0-1背包了，按照模板正常做
            for(int j = V;j >= it.v;j --)
                f[j] = Math.max(f[j], f[j - it.v] + it.w);
        }
        System.out.println(f[V]);
    }
}