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

/*
    朴素更新
    for (int i = 0; i < n; i++) {
        cin >> v >> w >> s;
        for (int j = 0; j <= m; j++)
            for (int k = 0; k < s && k * v <= j; k++)
                f[j] = max(f[j], f[j-k*v] + k * w);
    }
    
    
     由 f[j] = max(f[j], f[j-v] + w, f[j-2*v] + 2*w, ...);
    
    
    可以观测到 f[j] f[j-v] f[j-2v] ... f[r] （r = j % v）是一类，即后面的j只会通过同类的前面元素递归过来
    因此可以分成如下几类
    f[0] f[v] f[2v] ... f[kv]; 
    f[1] f[1+v] f[1+2v] ... f[1+kv];
    ...
    f[r] f[r+v] f[r+2v] ... f[r+kv];  
    其中 0 <= r < v;
    
    所以我们可以从0到r遍历更新每一类。
    此外还有一个限制。f[j] 需要借助 f[j-v] .. f[j-s*v] 这些元素更新，并不是同类所有元素，而是一个长度为s的窗口
    因此可以用滑动窗口在O(n)的时间内对一类物品进行更新
    
    同时由于用滑动窗口需要从前往后更新，而滚动数组的更新顺序正好相反，所以需要在维护一个备份数组，每次更新f前把f的
    内容拷贝到g中。只用g来更新。
    
    单调队列中存储的元素是什么？
    由f[j] = max(f[j], f[j-k*v] + k * w) (1 <= k <= s)可知
        当更新g[j](f[j])时，单调队列中存储的是另 f[i-k*v]+k*w (1 <= k <= s)
        最大的元素k。
*/

#include <iostream>
#include <cstring>

using namespace std;
const int N = 20010;
int f[N], g[N], q[N];

int main() {
    int n, m, v, w, s;
    cin >> n >> m;
    
    for (int i = 0; i < n; i++) {
        cin >> v >> w >> s;
        memcpy(g, f, sizeof f);
        for (int j = 0; j < v; j++) {
            int hh = 0, tt = -1;
            for (int k = j; k <= m; k += v) {
                if (tt >= hh && k - q[hh] > s * v) hh++; // 区间[k-s*v, k-v]中
                while (tt >= hh && g[q[tt]] + (k-q[tt])/v*w <= g[k]) tt--; // 
                q[++tt] = k;
                f[k] = g[q[hh]] + (k-q[hh])/v*w;
            }
        }
    }
    
    cout << f[m] << endl;
    
    return 0;
}