完全背包问题：动态规划解法与优化技巧

1. 完全背包问题概述

完全背包问题是动态规划中的经典问题之一，与0/1背包问题类似但有一个关键区别：每种物品可以选取无限次。这个问题在实际中有广泛应用，比如资源分配、投资组合优化等场景。

我们先明确几个基本概念：

• 背包容量(V)：背包能承载的最大体积
• 物品集合：每种物品有体积(vol[i])和价值(val[i])
• 目标：在不超过背包容量的前提下，装入物品使总价值最大

与0/1背包只能选一次不同，完全背包中每种物品可以选0次、1次...直到超过背包容量。这个特性使得它的状态转移方程推导更加复杂但同时也更有趣。

2. 二维状态转移方程的推导

2.1 基本思路分析

设f[i][j]表示前i种物品装入容量为j的背包的最大价值。对于第i种物品，我们面临的选择是：选0个、选1个...选k个（直到k*vol[i] > j）。

因此，状态转移可以表示为：

code复制f[i][j] = max{
    f[i-1][j],  // 不选第i种物品
    f[i-1][j-vol[i]] + val[i],  // 选1个
    f[i-1][j-2*vol[i]] + 2*val[i],  // 选2个
    ...
    f[i-1][j-k*vol[i]] + k*val[i]   // 选k个
}

这个表达式看起来非常冗长，我们需要找到简化的方法。

2.2 关键数学推导

观察上面的表达式，我们发现其中存在重复计算。令j' = j - vol[i]，则有：

code复制f[i][j'] = max{
    f[i-1][j'],
    f[i-1][j'-vol[i]] + val[i],
    f[i-1][j'-2*vol[i]] + 2*val[i],
    ...
    f[i-1][j'-(k-1)*vol[i]] + (k-1)*val[i]
}

现在我们在等式两边都加上val[i]：

code复制f[i][j'] + val[i] = max{
    f[i-1][j'] + val[i],
    f[i-1][j'-vol[i]] + 2*val[i],
    f[i-1][j'-2*vol[i]] + 3*val[i],
    ...
    f[i-1][j'-(k-1)*vol[i]] + k*val[i]
}

神奇的事情发生了：这个结果正好对应原始表达式中选1个、选2个...选k个的情况。因此我们可以将原始表达式简化为：

code复制f[i][j] = max(f[i-1][j], f[i][j-vol[i]] + val[i])

这个简化大大降低了计算复杂度，从需要考虑k种情况变为只需要比较两种情况。

3. 一维优化的实现

3.1 空间优化原理

观察二维状态转移方程，我们发现f[i][j]只依赖于：

1. 上一行同列的值f[i-1][j]
2. 当前行前面的值f[i][j-vol[i]]

这意味着我们可以将二维数组优化为一维数组，只需要确保在计算f[j]时，f[j-vol[i]]已经被更新过。

3.2 正序遍历的重要性

这与0/1背包问题的遍历顺序形成鲜明对比：

• 0/1背包：逆序遍历（从大到小），确保每个物品只选一次
• 完全背包：正序遍历（从小到大），允许物品被多次选择

核心代码实现：

cpp复制for(int i=0; i<n; i++) {
    for(int j=vol[i]; j<=V; j++) {  // 正序是关键
        f[j] = max(f[j], f[j-vol[i]] + val[i]);
    }
}

3.3 实际应用示例

假设背包容量V=8，有3种物品：

• 物品1：vol=2, val=3
• 物品2：vol=3, val=4
• 物品3：vol=4, val=5

计算过程如下：

初始化：f[0]=0, f[1..8]=0

处理物品1（vol=2）：

• j=2: f[2]=max(0, f[0]+3)=3
• j=4: f[4]=max(0, f[2]+3)=6
• j=6: f[6]=max(0, f[4]+3)=9
• j=8: f[8]=max(0, f[6]+3)=12

处理物品2（vol=3）：

• j=3: f[3]=max(0, f[0]+4)=4
• j=5: f[5]=max(0, f[2]+4)=7
• j=6: f[6]=max(9, f[3]+4)=9
• j=7: f[7]=max(0, f[4]+4)=10
• j=8: f[8]=max(12, f[5]+4)=12

处理物品3（vol=4）：

• j=4: f[4]=max(6, f[0]+5)=6
• j=8: f[8]=max(12, f[4]+5)=12

最终结果：f[8]=12

4. 常见问题与调试技巧

4.1 为什么正序能实现多次选择？

正序遍历时，当计算f[j]时，f[j-vol[i]]可能已经包含了当前物品的选取，因此相当于允许重复选择。这与现实生活中的"先拿一个，再拿一个"的过程是一致的。

4.2 边界条件处理

常见错误包括：

1. 没有初始化f[0]=0
2. 体积循环从0开始而不是vol[i]
3. 数组大小不足导致越界

建议的防御性编程：

cpp复制vector<int> f(V+1, 0);  // 初始化为0
for(int i=0; i<n; i++) {
    if(vol[i] > V) continue;  // 跳过装不下的物品
    for(int j=vol[i]; j<=V; j++) {
        f[j] = max(f[j], f[j-vol[i]] + val[i]);
    }
}

4.3 如何验证算法正确性？

1. 小规模手工计算验证
2. 对比二维和一维的结果
3. 添加打印语句跟踪状态变化

调试时可以输出中间结果：

cpp复制cout << "Processing item " << i << " (vol=" << vol[i] << ", val=" << val[i] << ")" << endl;
for(int j=0; j<=V; j++) {
    cout << "f[" << j << "]=" << f[j] << " ";
}
cout << endl;

5. 性能优化与扩展

5.1 常数优化技巧

1. 预处理过滤vol[i]>V的物品
2. 对于相同体积的物品，只保留价值最高的
3. 如果物品价值密度(val/vol)很低，可以提前排除

5.2 变种问题

1. 恰好装满：初始化时f[0]=0，其他f[j]=-∞
2. 方案计数：将max改为sum
3. 混合背包：部分物品有限制次数

5.3 实际应用建议

1. 对于大规模问题，可以考虑滚动数组进一步优化空间
2. 在竞赛中，通常直接使用一维实现
3. 注意物品体积和价值的数据范围，防止整数溢出

6. 个人经验分享

在实际编码比赛中，完全背包问题有几个容易出错的点值得注意：

1. 遍历顺序混淆：我曾经多次因为把完全背包和0/1背包的遍历顺序搞反而失分。一个好的记忆方法是：完全背包是"无限供应"，所以可以"正着拿"；0/1背包是"只有一个"，所以要"倒着拿"。

2. 初始化的陷阱：如果题目要求"恰好装满"，初始化方式完全不同。我建议在代码模板中加入清晰的注释说明不同场景的初始化要求。

3. 空间优化的思维：从二维到一维的优化不是简单的技巧，而是对问题本质的理解。我建议初学者先写出二维版本，确保理解正确后再进行优化。

4. 调试技巧：对于复杂的背包问题，我通常会先在小样例上手工计算，然后用打印语句验证每个物品处理后的状态数组，这样可以快速定位逻辑错误。

最后提醒一点：虽然一维实现简洁高效，但在解决一些变种问题时（如需要记录具体方案），可能需要回退到二维实现。理解两者的等价性和转换方法非常重要。