多重背包问题-单调队列优化-C++实现(深入刨析)

前面的话

这是我学习初学算法时研究最久的单个问题了，挺有纪念意义的，吸收了很多大佬的题解并断断续续整理了一些笔记，希望大家看完有点收获的话希望能点赞鼓励我一下hh

多重背包问题

有N种物品和一个容量是V的背包

第i种物品最多有si件，每件体积是vi，价值是wi

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大
输出最大价值

输入格式

第一行两个整数N, V，用空格隔开，分别表示物品种数和背包容积

接下来有N行，每行三个整数vi, wi, si，用空格隔开，分别表示第i种物品的体积、价值和数量

输出格式

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

数据范围

$0<N\le 1000$
$0<V\le 20000$
$0<vi,wi,si\le 20000$

输入样例
4 5
1 2 3
2 4 1
3 4 3
4 5 2

输出样例
10

思路

1. 使用二进制优化的时间复杂度为$O(nvlogs)$，而本题的操作数量级在$10^9$，故会导致超时，适用单调队列优化

2. 若总体积为$m$，当前物品价值为$w$，总体积为$v$，数量为$s$，设$t$满足$m-t\times v\ge 0$且$m-(t+1)\times v<0$，即不超过总体积情况下的最大物品数量

3. 当$t\le s$时，物品的限制为体积$m$，相当于在体积$m$下当前物品的数量无限，故多重背包问题可通过完全背包问题的解法处理

4. 当$t>s$时，物品的限制为数量$s$，可以按完全背包的思路列出代码

   // 设s = 3, t = 4, p为区间[0, m % v]的任意整数
   // 设f(i-1,j) = g(j)
   f(i,     j) = max(g(j),g(j-v)+w,g(j-2v)+2w,g(j-3v)+3w)
   f(i,j- v+p) = max(     g(j-v),  g(j-2v)+ w,g(j-3v)+2w,g(j-4v)+3w)
   f(i,j-2v+p) = max(              g(j-2v),   g(j-3v)+ w,g(j-4v)+2w)
   f(i,j-3v+p) = max(                         g(j-3v),   g(j-4v)+ w)
   f(i,j-4v+p) = max(                                    g(j-4v))
   

   • 当$k$满足$k\le t-s$时，$j-kv$的体积仍然能容纳$s$个物品，故第$k$个式子比第$k-1$个的式子多一项，则无法通过第$k$个式子的最大值推导第$k-1$个式子的最大值
   • 当$k$满足$k>t-s$时，此时$j-kv$的体积仅能容纳小于$s$个物品，物品限制为体积，故第$k$个式子和第$k+1$个项数相同，则可以通过第$k+1$个式子推导第$k$个式子
   • 故能够从下到上通过类似长度为$s$的滑动窗口形式更新状态，每次取出维护的滑动窗口的极值即可
   • 综上可知，枚举所有余数$p$，对于当前$p$，再从小到大枚举更新所有体积$j$满足$j\%v=p$的当前$i$层的所有状态$f(i,j)$，最终得到当前$i$层的所有状态$f(i,j)$

5. 对当前余数$p$，若$t>s$，则所有需要更新的体积的序列为

   p p+v p+2v p+3v ... p+(s-1)v p+sv p+(s+1)v ... p+tv
   // 已知体积为从小到大更新, 故该序列为从左到右枚举
   

   • 若需要更新序列中第$i$个元素，则需要得到以$i-s$为起点的长度为$s$的区间的状态的最大值，故适用单调队列实现滑动窗口，快速获取该区间的最大值

     • 序列中任意元素$p+kv$表示状态$f(i-1,p+kv)$

   • 注意每个状态$f(i-1,p+kv)$在相邻层中存在偏移量w

     f(i,p) = f(i-1,p)
     f(i,p+ v) = max(f(i-1,p)+ w, f(i-1,p+v))
     f(i,p+2v) = max(f(i-1,p)+2w, f(i-1,p+v)+w, f(i-1,p+2v))
     

     故每次比较对原式进行等价变换，实现状态的直接比较

     f(i,p) = f(i-1,p)
     f(i,p+ v) = max(f(i-1,p), f(i-1,p+v)-w) + w
     f(i,p+2v) = max(f(i-1,p), f(i-1,p+v)-w, f(i-1,p+2v)-2w) + 2w
     // 对k层所有状态减去kw再进行比较入队, 故入队的元素为f(i,p+kv)-kw, 出队时加上kw获取真实值
     

6. 时间复杂度

   $O(nv)$

实现

#include <bits/stdc++.h>
using namespace std;

const int N = 2e4 + 10;

int n, m;
int q[N];
int dp[N], back[N];

int main(){
    cin >> n >> m;
    for(int i = 0; i < n; i++){
        int v, w, s;
        cin >> v >> w >> s;
        
        // 由于使用滚动数组且从小到大枚举体积
        // 故需要辅助数组保存i - 1层的状态
        memcpy(back, dp, sizeof dp);
        
        // 枚举所有余数
        // 更新当前i层的所有体积
        for(int u = 0; u < v; u++){
            // 体积从小到大枚举更新
            // 单调队列中的元素是体积
            int tt = -1, hh = 0;
            for(int j = u; j <= m; j += v){
                // 若当前维护的区间长度大于s则出队
                if(tt >= hh && q[hh] < j - s * v) hh++;
                // 注意获取的是当前元素之前的长度为s的窗口的最大值
                // 故先处理再入队
                // 注意出队时获取真实值
                // 需要判断队列是否为空
                // 因为使用的是数组模拟队列
                // 故若不判断则第一次枚举时dp[k]可能被窗口外的t[0]更新
                if(tt >= hh) dp[j] = max(dp[j], back[q[hh]] + (j - q[hh]) / v * w);
                while(tt >= hh && back[j] - (j - u) / v * w >= back[q[tt]] - (q[tt] - u) / v * w) tt--;
                q[++tt] = j;
            }
        }
    }
    
    cout << dp[m] << endl;
    
    return 0;
}