单调队列优化动态规划

先来看这道题：

USACO 2011 Open Gold Mowing the Lawn 修剪草坪

After winning the annual town competition for best lawn a year ago,
Farmer John has grown lazy; he has not mowed the lawn since then
and thus his lawn has become unruly. However, the competition is
once again coming soon, and FJ would like to get his lawn into
tiptop shape so that he can claim the title.

Unfortunately, FJ has realized that his lawn is so unkempt that he
will need to get some of his N (1 <= N <= 100,000) cows, who are
lined up in a row and conveniently numbered 1..N, to help him. Some
cows are more efficient than others at mowing the lawn; cow i has
efficiency E_i (0 <= E_i <= 1,000,000,000).

FJ has noticed that cows near each other in line often know each
other well; he has also discovered that if he chooses more than K
(1 <= K <= N) consecutive (adjacent) cows to help him, they will
ignore the lawn and start a party instead. Thus, FJ needs you to
assist him: determine the largest total cow efficiency FJ can obtain
without choosing more than K consecutive cows.

显然这是一道动态规划题目，我们先简化题目。题意是这样的：

FJ 有 N(1≤N≤100000) 只排成一排的奶牛，编号为 1...N。每只奶牛的效率是不同的， 奶牛 i 的效率为 Ei(0≤Ei≤1000000000)。靠近的奶牛们很熟悉，因此，如果 FJ 安排超过 K(1≤K≤N) 只连续的奶牛，那么，这些奶牛就会罢工去开派对。现在 FJ 需要你帮助计算可以得到的最大效率。

如果我们用 dp[i] 来表示前i头奶牛的最大效率，那么我们可以写出这样的转移方程：

dp[i]=max​{dp[j−1]+sum[i]−sum[j]} (i−K≤j≤i)

这样的转移方程的时间复杂度是O(NK)，观察这道题的数据量，相当于O(N^2)，显然是不行的。

仔细观察，实际上对于 dp[i] 来说，我们需要找到一个决策 j(i−K≤j≤i) 使得 dp[j−1]−sum[j] 最大化。再看，不难发现，i和j都是单调递增的，这让我们联想到以前做过的Sliding Windows，窗户的两边也是单调的对吧。所以这道题我们其实也可以用单调队列来优化。我们用这个单调队列来维护这个下标j的位置。

#include <stdio.h>

typedef long long LL;
const int maxn = 100010;
LL dp[maxn], sum[maxn];
int que[maxn], E[maxn];
int head, tail;
LL max(LL a, LL b) {
    return a > b? a : b;
}
void add(int j) {
    while (head < tail && dp[j - 1] - sum[j] >= (que[tail - 1] > 0 ? dp[que[tail - 1] - 1] : 0) - sum[que[tail - 1]]) {
        --tail;
    }
    que[tail++] = j;
}
void del(int j) {
    if (head < tail && que[head] == j) {
        ++head;
    }
}
int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    sum[0] = 0;
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &E[i]);
        sum[i] = sum[i - 1] + E[i];
    }
    dp[0] = 0;
    que[tail++] = 0;
    for (int i = 1; i <= n; ++i) {
        add(i);
        del(i - k - 1);
        int j = que[head];
        dp[i] = (j > 0 ? dp[j - 1] : 0) + sum[i] - sum[j];
    }
    LL ans = max(dp[n], dp[n - 1]);
    printf("%lld
", ans);
    return 0;
}