单调队列优化dp

题目链接:https://www.luogu.com.cn/problem/P5858

状态: $dp[i][j]$: 放入第 $j$ 种原料后锅中共 $i$ 种原料时的最优值
阶段: $j$
决策: $dp[i][j] = \max_{k<j+s}(dp[k][j-1]+k*a[j])$
边界: $dp[1][1]=a[1]$
优化1:
很明显 $dp$ 数组第 $i$ 行的的大小仅与第 $i-1$ 行有关 ,故可以用滚动数组优化其空间复杂度.
优化2:
$\max_{k<j+s}\{dp[k][j-1]+k*a[j]\} = \max_{k<j+s}\{dp[k][j-1]\}+k*a[j]$
这里涉及到区间最大值的查询:
暴力计算的话复杂度为$O(n)$
其次我们容易想到用线段树来维护区间的最大值, 复杂度可以降为$O(logn)$
但其实对于形如 $dp[i]=min\{dp[j]+f[j]\},0<=j<i 或 i-a<=j<=i-b$ 的转移方程还有更高效的方法,可以看到我们查询的区间是不断往右移动的,故我们可以利用查询区间的有序性,用单调队列进行最大值的维护,对于$dp[l_1][j-1]$和$dp[l_2][j-1]$, 若 $l_1<l_2$ , 则对于$l_2$有效的查询区间 ,$l_1$要么过时 , 要么也有效 , 故我们可以维护一个单调递减的单调队列 , 队列中存下标.这样我们可以将复杂度降为$O(1)$

代码如下:

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define int ll
const int maxn = 5e3 + 5;

int n, w, s, a[maxn], dp[2][maxn], q[maxn], l, r;

void solve()
{
    dp[0][1] = a[1];
    int lastp = 0, curp, p;
    for (int i = 2; i <= n; i++) {
        curp = lastp ^ 1, l = 1, r = 0, p = 1;
        for (int j = 1; j <= i && j <= w; j++) {
            while (p <= i - 1 && p <= j + s - 1) {
                while (r >= l && dp[lastp][p] >= dp[lastp][q[r]]) r--;
                q[++r] = p++;
            }
            while (q[l] < j - 1) l++;
            dp[curp][j] = dp[lastp][q[l]] + j * a[i];
        }
        lastp = curp;
    }
    cout << *max_element(dp[(n + 1) % 2] + 1, dp[(n + 1) % 2] + w + 1);
}

signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cin >> n >> w >> s;
    for (int i = 1; i <= n; i++) cin >> a[i];
    solve();

    return 0;
}