单调队列及优化DP poj2823/poj1821/poj2373
用于求解某个元素所在的一定区间内的最优值。队列中存放元素索引，因为要根据区间来将无效的队头出队。
应用一：求滑动窗口内的最大/小值
题目链接： poj2823 Sliding Window
当区间长度固定时，对第i个元素，有效区间为[i - k + 1, i]。以最大值为例，维护一个单调下降的队列，存放当前的最大值、次大值……
从左至右扫描数组，每次将a[i]与队尾j比较，若a[i] > a[j]，则i比j更优，因为对位于i之后的某个元素t而言，若j在t的窗口内，则i一定也在t的窗口内（i的位置在j之后），而a[i] > a[j]，所以i比j更优，将队尾出队，直到队尾不小于a[i]，然后将a[i]入队。
对于队头元素，因为随着窗口的滑动，前面元素的区间最大值可能会移出窗口，当队头位于窗口之外，即：小于区间下限时，要将其出队，因为它对当前元素及后面的元素都没有意义。
代码如下：
#include <cstdio>
using namespace std;
#define N 1000005
#define MIN 0
#define MAX 1
int n, k, a[N], qu[2][N], tail[2], head[2], res[2][N];
void process(int pos, int type){
if(type == MIN){
while(tail[type] > head[type] && a[qu[type][tail[type] - 1]] > a[pos])
--tail[type];
}
else{
while(tail[type] > head[type] && a[qu[type][tail[type] - 1]] < a[pos])
--tail[type];
}
qu[type][tail[type] ++] = pos;
while(qu[type][head[type]] < pos - k + 1)
++head[type];
if(pos >= k - 1)
res[type][pos] = a[qu[type][head[type]]];
}
int main(){
scanf("%d %d", &n, &k);
for(int i = 0; i < n; ++i)
scanf("%d", &a[i]);
for(int i = 0; i < n; ++i){
process(i, MIN);
process(i, MAX);
}
for(int i = 0; i < 2; ++i){
for(int j = k - 1; j < n; ++j)
printf("%d ", res[i][j]);
printf("\n");
}
return 0;
}
应用二：优化DP
当状态转移方程满足以下条件时，可以使用单调队列来优化复杂度：
其中，k在i的有效区间
内，f[k]是可以根据k在常数时间内确定的唯一的常数。并且
和
随i单调不降。即：随着i的推进，有效区间是向右滑动的(也可能一端不动)，但至少不会左移。
例题①：上限固定，下限递增
题目链接： poj1821 Fence
dp[i][j]表示前i个工人负责前j块木板，则dp[i][j - 1]表示第j块木板不涂，dp[i - 1][j]表示第i个工人不涂
i. 
时，
,因为第i个工人必须涂s[i]，否则不涂
ii. 
时，
iii. 
时，
其中第二个转移方程，变换得:
因为下标k随着j递增,满足适用条件，因此可以使用单调队列优化。
因为k关于j单调，关于i则不一定，所以应该将i放在外层循环，j在内层，则区间相对于j来说，下限递增，上限固定为s[i]。注意入队时，一定要保证入队的索引在有效区间内！
代码如下：
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 16005
#define K 105
struct worker{
int l, s, p;
friend bool operator< (const worker& a, const worker& b){
return a.s < b.s;
}
}w[K];
int dp[K][N], left[K], right[K], qu[N];
int main(){
int n, m;
scanf("%d %d", &n, &m);
for(int i = 1; i <= m; ++i)
scanf("%d %d %d", &w[i].l, &w[i].p, &w[i].s);
sort(w + 1, w + m + 1);
for(int i = 1; i <= m; ++i){
left[i] = max(w[i].s - w[i].l, 0);
right[i] = min(w[i].s + w[i].l, n + 1);
}
w[0].l = w[0].s = w[0].p = 0;
memset(dp, 0, sizeof(dp));
for(int i = 1; i <= m; ++i){
int head = 0, tail = 0;
for(int j = 0; j < w[i].s; ++j)
dp[i][j] = dp[i - 1][j];
for(int j = left[i]; j < w[i].s; ++j){ //入队的k的范围
int tmp = dp[i - 1][j] - j * w[i].p;
while(head < tail && (dp[i - 1][qu[tail - 1]] - qu[tail - 1] * w[i].p) < tmp)
--tail;
qu[tail ++] = j;
}
for(int j = w[i].s; j < right[i]; ++j){
while(qu[head] < j - w[i].l)
++head;
int tmp = dp[i - 1][qu[head]] - qu[head] * w[i].p;
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
dp[i][j] = max(dp[i][j], tmp + j * w[i].p);
}
for(int j = right[i]; j <= n; ++j)
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
printf("%d\n", dp[m][n]);
return 0;
}
例题②： 上下限都递增
题目链接： poj2373 Dividing the Path
dp[i]表示前i块区域恰好被覆盖完所需的喷头数，显然只有偶数下标的点才有解。
dp[i] = min{dp[k]} + 1, i - 2 * b <= k <= i - 2 * a;
由于每个range内的点只能被一个喷头覆盖，当两个range有重叠时，需要用一个喷头去覆盖这两个range。则这中间的点都不是合法解，否则，区间会以该点为边界，被两个喷头覆盖。所以先对点进行标记，位于区间内的点不进行求解。初始化时，dp[0]为合法解，设为0，并将下标0入队。
队列中可能存在INF的元素，但不影响结果。因为本身就存在无解的点。
队头出队时需要判断索引是否满足下限，将队头作为最优解时需要判断是否满足上限（不能出队，因为该点可能满足后续元素的上限）
代码如下：
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
#define L 1000005
#define N 1005
#define INF 0x3f3f3f3f
int dp[L], qu[L];
bool covered[L];
int main(){
int n, l, A, B, cnt = 0;
scanf("%d %d %d %d", &n, &l, &A, &B);
for(int i = 0; i < n; ++i){
int st, en;
scanf("%d %d", &st, &en);
memset(covered + st + 1, true, (en - st - 1) * sizeof(bool));
}
memset(dp, INF, sizeof(dp));
dp[0] = 0, qu[0] = 0;
int head = 0, tail = 1;
for(int i = 2; i <= l; i += 2){
if(covered[i])
continue;
while(head < tail && qu[head] < i - 2 * B)
++head;
if(head < tail && qu[head] <= i - 2 * A && dp[qu[head]] < INF)
dp[i] = dp[qu[head]] + 1;
while(head < tail && dp[qu[tail - 1]] > dp[i]) //注意没有等号，贡献N个WA
--tail;
qu[tail ++] = i;
}
printf("%d\n", dp[l] >= INF ? -1 : dp[l]);
return 0;
}
注意注释中对等号的强调，使用单调队列时，队尾与当前元素的比较，使用<或>，不要加等号。否则很容易出错。