多重背包之单调队列优化

问题与参考资料来源

多重背包的单调队列优化问题思路与代码皆来源于公众号“宫水三叶的刷题日记”的DP背包问题系列讲解文章的第十篇文章。本文记录对代码的具体理解，多重背包的单调队列优化问题的思路请参考原文章。

问题描述

有N种物品和一个容量为C的背包，每种物品数量有限。
第i种物品的体积为v[i]，价值为w[i]，数量为s[i]。
问选择哪几种物品，每种物品选择多少件 ，可使得总价值最大。

示例

输入：N = 2，C = 5，v = [1, 2]，w = [1, 2]，s = [2, 1]
输出：4
解释：选两件物品1，再选一件物品2，可使价值最大。

代码

/*
有2种物品，背包容量为20，A物品体积为5，价值为5，数量为2，B物品体积为4，价值为6，数量为3
先遍历A物品，后遍历B物品

A物品枚举余数情况为：
    j = 0, k = 0, 5, 10, 15, 20
    j = 1, k = 1, 6, 11, 16
    j = 2, k = 2, 7, 12, 17
    j = 3, k = 3, 8, 13, 18
    j = 4, k = 4, 9, 14, 19
    
B物品枚举余数情况为：
    j = 0, k = 0, 4, 8, 12, 16, 20
    j = 1, k = 1, 5, 9, 13, 17
    j = 2, k = 2, 6, 10, 14, 18
    j = 3, k = 3, 7, 11, 15, 19
*/


class Solution {
    public int maxValue(int N, int C, int[] s, int[] v, int[] w) {
        int[] dp = new int[C + 1];
        int[] g = new int[C + 1]; // 辅助队列，记录的是上一次的结果
        int[] q = new int[C + 1]; // q队列中存储的是背包的容量且该队列是单调递减的队列

        // 枚举物品
        for (int i = 0; i < N; i++) {
            int vi = v[i];
            int wi = w[i];
            int si = s[i];

            // 将上次算的结果存入辅助数组中
            g = dp.clone();

            // 枚举余数
            for (int j = 0; j < vi; j++) {
                // 初始化队列，head 和 tail 分别指向队列头部和尾部
                int head = 0, tail = -1;
                // 枚举同一余数情况下，有多少种方案。
                // 例如余数为 1 的情况下有：1、vi + 1、2 * vi + 1、3 * vi + 1 ...
                for (int k = j; k <= C; k+=vi) {
                    dp[k] = g[k];
                    // 将不在窗口范围内的值弹出
                    // 这一步的意思是假如此时遍历的是A物品，j = 0, k = 20, 则dp[20]只能由dp[15]、dp[10]、dp[5]和dp[0]转移而来
                    // 但是又因为A物品只有两件，因此dp[20]只能由dp[15]、dp[10]转移而来，因此0和5不在窗口范围内。
                    if (head <= tail && q[head] < k - si * vi) head++;
                    // 如果队列中存在元素，直接使用队头来更新
                    if (head <= tail) dp[k] = Math.max(dp[k], g[q[head]] + (k - q[head]) / vi * wi);
                    // 当前值比队尾值更优，队尾元素没有存在必要，队尾元素出队
                    // 因为q是一个单调递减的队列，因此只要当前值比队尾值更优，就要不断弹出队尾值，确保队列是单调递减的，队首元素是最大的。
                    while (head <= tail && g[q[tail]] - (q[tail] - j) / vi * wi <= g[k] - (k - j) / vi * wi) tail--;
                    // 将新下标入队 
                    q[++tail] = k;
                }
            }
        }
        return dp[C];
    }
}