多重背包问题：从朴素解法到二进制与单调队列优化-代码聚汇网

多重背包问题：从朴素解法到二进制与单调队列优化

多重背包问题动态规划二进制优化

|难度：普通|阅读约 11 分钟

1. 多重背包问题概述

多重背包问题是动态规划领域的经典问题之一，也是算法竞赛和面试中的常客。与01背包和完全背包不同，多重背包问题中每种物品的数量是有限的，这给问题的求解带来了新的挑战。

我第一次接触这个问题是在准备算法竞赛时，当时被它看似简单实则复杂的特性所困扰。经过反复练习和思考，我发现理解多重背包的核心在于掌握如何高效处理物品数量的限制。在AcWing算法基础课中，这个问题被作为动态规划章节的重点内容进行讲解。

多重背包问题的标准形式可以描述为：给定一个容量为V的背包和N种物品，每种物品i有体积vi、价值wi和数量si。我们需要选择装入背包的物品，使得总体积不超过背包容量，同时总价值最大。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 多重背包问题的朴素解法

2.1 基本思路解析

最直观的解法是将多重背包问题转化为01背包问题来处理。具体来说，对于每种物品i，我们可以将其视为si个独立的物品，每个物品的体积和价值相同。这样，问题就变成了一个标准的01背包问题。

这种方法的实现相对简单：

初始化一个一维数组dp，大小为V+1，所有元素初始化为0
对于每种物品i，将其拆分为si个独立物品
对每个拆分后的物品，按照01背包的方式进行状态转移

状态转移方程为：
dp[j] = max(dp[j], dp[j - vi] + wi) 其中j从V递减到vi

2.2 朴素解法的实现代码

cpp复制#include <iostream>
#include <algorithm>
using namespace std;

const int N = 110;
int dp[N];

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

2.3 朴素解法的时间复杂度分析

这种朴素解法的时间复杂度为O(N×V×S)，其中N是物品种类数，V是背包容量，S是每种物品的最大数量。当S较大时（比如达到1e5），这种解法的时间复杂度会变得非常高，无法在合理时间内完成计算。

提示：在实际编程竞赛中，当N=100，V=100，S=10000时，朴素解法的时间复杂度将达到1e8量级，这在大多数情况下都会超出时间限制。

3. 多重背包问题的二进制优化

3.1 二进制优化原理

二进制优化是解决多重背包问题的经典优化方法。其核心思想是利用二进制的特性，将物品数量进行拆分，从而将多重背包问题转化为01背包问题，同时显著减少物品的总数量。

具体来说，对于数量为s的物品，我们可以将其拆分为1,2,4,...,2^k,(s-2^{k+1}+1)这样的组合。这样做的原因是任何数字都可以表示为若干个2的幂次方的和，这种表示方式可以覆盖所有可能的数量选择。

例如，数量为7的物品可以拆分为1,2,4；数量为10的物品可以拆分为1,2,4,3。通过这种方式，原来需要处理7个或10个独立物品的情况，现在只需要处理3个或4个"组合物品"。

3.2 二进制优化的实现步骤

对于每种物品i，计算其数量s的二进制拆分
将拆分后的每个组合视为一个新的"物品"，其体积和价值为原物品的对应倍数
对拆分后的所有物品进行01背包处理

3.3 二进制优化的代码实现

cpp复制#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

const int N = 2010;
int dp[N];

struct Good {
    int v, w;
};

int main() {
    int n, m;
    vector<Good> goods;
    cin >> n >> m;
    
    for (int i = 0; i < n; i++) {
        int v, w, s;
        cin >> v >> w >> s;
        for (int k = 1; k <= s; k *= 2) {
            s -= k;
            goods.push_back({v * k, w * k});
        }
        if (s > 0) goods.push_back({v * s, w * s});
    }
    
    for (auto good : goods) {
        for (int j = m; j >= good.v; j--) {
            dp[j] = max(dp[j], dp[j - good.v] + good.w);
        }
    }
    
    cout << dp[m] << endl;
    return 0;
}

3.4 二进制优化的时间复杂度分析

经过二进制优化后，每种物品的数量s被拆分为log2(s)个组合物品。因此，总物品数量从原来的N×S减少到N×logS。时间复杂度相应地从O(N×V×S)降低到O(N×V×logS)。

对于前面的例子(N=100,V=100,S=10000)，优化后的时间复杂度约为100×100×14=1.4e5，相比朴素解法的1e8有了质的提升。

4. 多重背包问题的单调队列优化

4.1 单调队列优化原理

虽然二进制优化已经显著提升了算法效率，但在某些极端情况下还可以进一步优化。单调队列优化是一种更高级的优化方法，可以将时间复杂度降低到O(N×V)。

这种优化的核心思想是利用滑动窗口的最大值特性。对于每个体积v，我们可以将背包容量按照模v的余数进行分类，然后在每个分类中使用单调队列来维护可能的最大值。

4.2 单调队列优化的实现细节

将背包容量V按照物品体积v的余数分类
对于每个余数类别，使用单调队列维护可能的最大价值
在状态转移时，通过单调队列快速获取当前窗口内的最大值

4.3 单调队列优化的代码实现

cpp复制#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;

const int N = 20010;
int dp[N], pre[N], q[N];

int main() {
    int n, m;
    cin >> n >> m;
    
    for (int i = 0; i < n; i++) {
        int v, w, s;
        cin >> v >> w >> s;
        memcpy(pre, dp, sizeof(dp));
        
        for (int j = 0; j < v; j++) {
            int head = 0, tail = -1;
            for (int k = j; k <= m; k += v) {
                if (head <= tail && k - s * v > q[head]) head++;
                
                while (head <= tail && pre[q[tail]] - (q[tail] - j) / v * w <= pre[k] - (k - j) / v * w)
                    tail--;
                
                q[++tail] = k;
                dp[k] = pre[q[head]] + (k - q[head]) / v * w;
            }
        }
    }
    
    cout << dp[m] << endl;
    return 0;
}

4.4 单调队列优化的性能分析

单调队列优化将时间复杂度降低到了O(N×V)，这在物品数量特别大时优势明显。不过这种实现相对复杂，在一般的编程竞赛中，二进制优化通常已经足够应对大多数情况。

5. 实际应用中的注意事项

5.1 边界条件处理

在实际编码中，有几个边界条件需要特别注意：

背包容量为0时，最大价值显然为0
物品体积为0时，需要特殊处理（虽然这种情况在实际中很少见）
物品数量为0时，应该跳过处理

5.2 空间优化技巧

多重背包问题可以使用滚动数组或一维数组来优化空间复杂度。在实现时，我们通常：

使用一维数组代替二维数组
内层循环从大到小遍历，避免重复计算
对于单调队列优化，需要额外保存前一轮的状态

5.3 常见错误与调试

在实现多重背包问题时，新手常犯的错误包括：

内层循环遍历方向错误（应该从大到小）
二进制拆分不完整（漏掉最后剩余的部分）
单调队列的窗口范围计算错误
数组越界访问（特别是使用单调队列优化时）

调试时可以：

打印中间状态，观察dp数组的变化
使用小规模测试用例手动验证
对比朴素解法和优化解法的结果

6. 性能对比与选择建议

6.1 不同优化方法的比较

优化方法	时间复杂度	空间复杂度	实现难度	适用场景
朴素解法	O(NVS)	O(V)	简单	小规模数据
二进制优化	O(NVlogS)	O(V)	中等	中等规模数据
单调队列优化	O(NV)	O(V)	困难	大规模数据

6.2 选择建议

在实际应用中，我建议根据具体情况选择优化方法：

对于编程竞赛，通常二进制优化已经足够
在面试中，可以先介绍朴素解法，然后逐步优化
对于特别大的数据规模，才考虑单调队列优化
如果时间紧迫，优先实现二进制优化版本

7. 扩展与变种问题

7.1 多重背包的计数问题

除了求最大价值，多重背包还可以变形为计数问题：求恰好装满背包的方案数。这种变种只需要将状态转移方程中的max改为sum即可。

7.2 混合背包问题

混合背包是指同时包含01背包、完全背包和多重背包物品的问题。解决方法是对每种物品判断其类型，然后分别应用对应的状态转移。

7.3 二维费用背包问题

当背包限制条件增加时（如同时限制体积和重量），问题就变成了二维费用背包。解决方法是将dp数组扩展为二维，同时考虑两种限制条件。

8. 实战练习建议

要真正掌握多重背包问题，我建议按照以下步骤练习：

先实现朴素解法，理解基本思路
实现二进制优化版本，对比性能差异
尝试解决一些变种问题
在在线判题系统上提交代码验证

AcWing上提供了多重背包问题的系列练习题，从基础到提高都有覆盖。我特别推荐完成以下题目：

AcWing 5. 多重背包问题 II（二进制优化）
AcWing 6. 多重背包问题 III（单调队列优化）
AcWing 7. 混合背包问题
AcWing 8. 二维费用的背包问题

在实现过程中，我发现记录每种优化方法的特点和适用场景非常有帮助。可以建立一个表格，记录不同数据规模下各种方法的实际运行时间，这样在遇到新问题时能快速选择最合适的解法。