单调队列优化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;
}