---

一、问题描述

问题的抽象：给定 $n$ 种物品和一个背包，第 $i$ 种物品的体积为 $c_i$，价值为 $w_i$，背包的总容量为 $C$。如何选择装入背包的物品，使装入背包中的物品的总价值最大？与 0/1 背包问题 不同，完全背包问题 中每种物品的数量是无限的，即可以选择取 $0$ 件、$1$ 件、$2$ 件 $\cdots$ 直至背包容量允许的最大数量。

具体的问题可以看这道洛谷题：P1616 疯狂的采药，将 物品 换成了 草药，将 容量 换成了 时间，将 背包的容量 换成了 规定的时间。

二、解决方案

1. DP 状态的设计

引入一个 $(N+1)\times (C+1)$ 的二维数组 $dp[][]$，其中，$dp[i][j]$ 表示把前 $i$ 种（从第 $1$ 种到第 $i$ 种）物品装入容量为 $j$ 的背包中获得的最大价值。

每个 $dp[i][j]$ 都是一个 完全背包问题：将前 $i$ 种物品装入容量为 $j$ 的背包中获得的最大价值。所以 $dp[N][C]$ 就代表将前 $N$ 种物品装入容量为 $C$ 的背包中获得的最大价值。

2. 状态转移方程

假设已经递推到 $dp[i][j]$，分两种情况：

• 第 $i$ 种物品的体积比容量 $j$ 还大，不能装进容量为 $j$ 的背包。此时直接继承前 $i-1$ 种物品装进容量 $j$ 的背包的情况即可，即 $dp[i][j]=dp[i-1][j]$。
• 第 $i$ 种物品的体积比容量 $j$ 小，能装进背包。此时分为两种情况：
  • 多装一个第 $i$ 种物品。由于 完全背包问题 可以重复装同一种物品，所以先在 前 $i$ 种物品装进容量为 $j$ 的背包中，给这个第 $i$ 种物品空出 $c_i$ 的空间，从而得到背包 $dp[i][j-c[i]]$。然后将这个第 $i$ 种物品放入这个背包，背包的价值增加 $w_i$，从而有当前背包 $dp[i][j]=dp[i][j-c[i]]+w[i]$。
  • 不装第 $i$ 种物品（一个第 $i$ 种物品也不装）。直接继承前 $i-1$ 个物品装进容量 $j$ 的背包的情况即可，即 $dp[i][j]=dp[i-1][j]$。
  • 此时取这两者中的较大值作为当前背包的价值，状态转移方程为：$$dp[i][j]=max(dp[i-1][j],dp[i][j-c[i]]+w[i])$$

所以 完全背包问题 的特征如下：

• 重叠子问题 是 $dp[i][j]$。
• 最优子结构 是 $dp[i][j]$ 的状态转移方程。

完全背包 和 0/1 背包 不同之处在于 状态转移方程，而且区别只在装第 $i$ 种物品的情况：

• 由于 完全背包 可以重复装同一种物品，所以找 前 $i$ 种物品装进容量为 $j-c_i$ 的背包，称为 多装一个第 $i$ 种物品。
• 由于 0/1 背包 不可以重复装同一种物品，所以找 前 $i-1$ 种物品装进容量为 $j-c_i$ 的背包，称为 装第 $i$ 个物品。

3. 算法复杂度

• 时间复杂度：在计算时，需要计算二维矩阵 $dp[][]$ 中的每一个值，矩阵的大小是 $NC$，每次计算的时间为 $O(1)$，所以时间复杂度为 $O(NC)$。
• 空间复杂度：使用了大小为 $NC$ 的二维数组，所以空间复杂度为 $O(NC)$。

4. 举例

对于 P1616 题，有一个测试用例：背包的容量为 70，物品的数量为 3，物品的体积数组为 [71, 69, 1]，物品的价值数组为 [100, 1, 2]。

定义一个 4 * 71 的二维数组，如下所示（由于长度限制，中间的数全部用 ... 代替，... 代表的数 和 ... 两边的数 相同 或 有一定规律）：

先填充索引为 1 的行（第一个物品的体积为 71，价值为 100）：

然后填充索引为 2 的行（第二个物品的体积为 69，价值为 1）：

接着填充索引为 3 的行（第三个物品的体积为 1，价值为 2）：

最终，数组的 dp[3][70] 的位置存储着题目的结果——将前 3 种物品放入容量为 70 的背包的最大价值。

5. 实现

此时 $dp$ 的元素数量为 $10005\times 10000005$，明显 超出内存限制 了，此时需要优化空间复杂度。

// 建议在 C++ 环境下运行
#include <stdio.h>

typedef long long ll; // 用 ll 表示类型 long long

const ll MAX_N = 10005; // 最大的物品种类数，与题目有关
const ll MAX_C = 10000005; // 最大的背包容量，与题目有关
ll N, C; // N 是物品的种类数，C 是背包的容量
ll c[MAX_N], w[MAX_N]; // c[i], w[i] 分别表示第 i 种物品的 体积 和 价值
ll dp[MAX_N][MAX_C]; // dp[i][j] 表示将前 i 种物品装入容量为 j 的背包中

// 取 x 和 y 中的较大值
ll max(ll x, ll y) {
    return x > y ? x : y;
}

// 进行动态规划
ll programming() {
    for (ll i = 1; i <= N; i++) {
        for (ll j = 1; j <= C; j++) {
            if (j < c[i]) { // 装不下第 i 种物品
                dp[i][j] = dp[i - 1][j];
            } else { // 能装下第 i 种物品
                dp[i][j] = max(
                    dp[i][j - c[i]] + w[i], // 多装一个第 i 种物品
                    dp[i - 1][j] // 一个第 i 种物品都不装
                );
            }
        }
    }
    return dp[N][C];
}

int main() {
    // 读取数据，这里使用 lld 表示读取的整数为 long long 类型
    scanf("%lld %lld", &C, &N);
    for (ll i = 1; i <= N; i++) {
        scanf("%lld %lld", &c[i], &w[i]);
    }

    // 进行动态规划
    printf("%lld", programming());
    return 0;
}

6. 滚动数组实现

• 0/1 背包 的单行数组实现需要将倒序内层循环 for (int j = C; j >= 1; j++)。
  • 这是因为计算 $dp[i][j]$ 使用了 $dp[i-1][j-c[i]]$，而 $c[i]$ 的大小不知道，所以不能贸然使用本行的新值覆盖上一行的旧值。
  • 此外，计算 $dp[i][j]$ 没有使用本行（即 $dp[i][]$）的值。所以 0/1 背包需要 倒序 的内层循环。
• 完全背包 的单行数组实现不需要倒序内层循环。仔细观察状态转移方程 $dp[i][j]=max(dp[i-1][j],dp[i][j-c[i]]+w[i])$。
  • 要计算 $dp[i][j]$ 需要使用本行的值 $dp[i][j-c[i]]$，也就意味着 $dp[i][j-c[i]]$ 必须比 $dp[i][j]$ 先计算。
  • 此外，计算 $dp[i][j]$ 之前 $dp[i-1][j]$ 还没有被它覆盖。所以 完全背包需要 正序 的内层循环。

#include <stdio.h>

typedef long long ll; // 用 ll 表示类型 long long

const ll MAX_N = 10005; // 最大的物品种类数，与题目有关
const ll MAX_C = 10000005; // 最大的背包容量，与题目有关
ll N, C; // N 是物品的种类数，C 是背包的容量
ll c[MAX_N], w[MAX_N]; // c[i], w[i] 分别表示第 i 种物品的 体积 和 价值
ll dp[MAX_C]; // 使用单行滚动数组，dp[j] 成为不断更新的变量，没有固定的含义

// 取 x 和 y 中的较大值
ll max(ll x, ll y) {
    return x > y ? x : y;
}

// 进行动态规划
ll programming() {
    for (ll i = 1; i <= N; i++) {
        for (ll j = 1; j <= C; j++) {
            if (j < c[i]) { // 装不下第 i 种物品
                dp[j] = dp[j]; // 实际上是一步多余的操作
            } else { // 能装下第 i 种物品
                dp[j] = max(
                    dp[j - c[i]] + w[i], // 多装一个第 i 种物品
                    dp[j] // 一个第 i 种物品都不装
                );
            }
        }
    }
    return dp[C];
}

// 可以将上面的 programming() 优化成以下的最简形式
/*
ll programming() {
    for (ll i = 1; i <= N; i++) {
        for (ll j = c[i]; j <= C; j++) { // 从能装下第 i 种物品的容量开始枚举
            dp[j] = max(
                dp[j - c[i]] + w[i], // 多装一个第 i 种物品
                dp[j] // 一个第 i 种物品都不装
            );
        }
    }
    return dp[C];
}
*/

int main() {
    // 读取数据，这里使用 lld 表示读取的整数为 long long 类型
    scanf("%lld %lld", &C, &N);
    for (ll i = 1; i <= N; i++) {
        scanf("%lld %lld", &c[i], &w[i]);
    }

    // 进行动态规划
    printf("%lld", programming());
    return 0;
}

三、总结

完全背包问题 的 完全 在于每种物品可以被重复地放入背包，针对这一问题，使用了 动态规划 的解决方案。由于空间复杂度比较高，还使用 滚动数组 的思想进行优化，从而将占用的空间 降维。