单调队列

给出一道例题 poj2823

我们知道，在暴力枚举的过程中，有一个地方是重复比较了，就是在找当前的f(i)的时候，i的前面其它m-1个数在算f(i-1)的时候我们就比较过了。
当你一个个往下找时，每一次都是少一个然后多一个，如果少的不是最大值，然后再问新加进来的，看起来很省时间对吧，那么如果少了的是最大值呢？第二个最大值是什么？？
那么我们能不能保存上一次的结果呢？当然主要是i的前k-1个数中的最大值了。答案是可以，这就要用到单调队列。
对于单调队列，我们这样子来定义：

• 1、维护区间最值
• 2、去除冗杂状态 如上题，区间中的两个元素a[i],a[j]（假设现在再求最大值）
  若 j>i且a[j]>=a[i] ，a[j]比a[i]还大而且还在后面（目前a[j]留在队列肯定比a[i]有用，因为你是往后推， 核心思想 !!!）
• 3、保持队列单调，最大值是单调递减序列，最小值反之
• 4、最优选择在队首

单调队列实现的大致过程： 
1、维护队首（对于上题就是如果队首已经是当前元素的m个之前，则队首就应该被删了,head++）
2、在队尾插入（每插入一个就要从队尾开始往前去除冗杂状态，保持单调性）

简单举例应用
数列为：6 4 10 10 8 6 4 2 12 14
N=10,K=3;
那么我们构造一个长度为3的单调递减队列：
首先，那6和它的位置0放入队列中，我们用(6,0)表示，每一步插入元素时队列中的元素如下
插入6：(6,0);
插入4：(6,0),(4,1);
插入10：(10,2);
插入第二个10，保留后面那个：(10,3);
插入8：(10,3),(8,4);
插入6：(10,3),(8,4),(6,5);
插入4，之前的10已经超出范围所以排掉：(8,4),(6,5),(4,6);
插入2，同理：(6,5),(4,6),(2,7);
插入12：(12,8);
插入14：(14,9);
那么f(i)就是第i步时队列当中的首元素：6,6,10,10,10,10,8,6,12,14
同理，最小值也可以用单调队列来做。

单调队列的时间复杂度是O（N），因为每个数只会进队和出队一次，所以这个算法的效率还是很高的。
注意：建议直接用数组模拟单调队列，因为系统自带容器不方便而且不易调试，同时，每个数只会进去一次，所以，数组绝对不会爆，空间也是S（N），优于堆或线段树等数据结构。

更重要的：单调是一种思想，当我们解决问题的时候发现有许多冗杂无用的状态时，我们可以采用单调思想，用单调队列或类似于单调队列的方法去除冗杂状态，保存我们想要的状态，

#include <bits/stdc++.h>

using namespace std;

#define ll long long
#define INF 0x3f3f3f3f
#define MAXN 1000010
#define MAXM 3010
#define _ 0

template < typename T > inline void read(T &x) {
    x = 0;
    T ff = 1, ch = getchar();
    while(!isdigit(ch)) {
        if(ch == '-') ff = -1;
        ch = getchar();
    }
    while(isdigit(ch)) {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    x *= ff;
}

inline void write(ll x) {
    if(x < 0) putchar('-'),x = -x;
    if(x > 9) write(x / 10);
    putchar(x % 10 + '0'); 
}

ll n,m,mn[MAXN],mx[MAXN],a[MAXN];
struct node {
    ll value;
    ll id;
}q[MAXN];

inline void getmin() {
    memset(q,0,sizeof(q));
    int head = 1,tail = 1;
    q[1].value = a[1];
    q[1].id = 1;
    for(int i = 2; i < m; ++i) {
        while(head <= tail && q[tail].value >= a[i]) --tail;
        q[++tail].value = a[i]; 
        q[tail].id = i;
    }
    for(int i = m; i <= n; ++i) {
        while(head <= tail && q[tail].value >= a[i]) --tail;
        q[++tail].value = a[i];
        q[tail].id = i;
        while(q[head].id < i - m + 1) ++head;
        mn[i] = q[head].value;
    }
}

inline void getmax() {
    memset(q,0,sizeof(q));
    int head = 1,tail = 1;
    q[1].value = a[1];
    q[1].id = 1;
    for(int i = 2; i < m; ++i) {
        while(head <= tail && q[tail].value <= a[i]) --tail;
        q[++tail].value = a[i];
        q[tail].id = i;
    }
    for(int i = m; i <= n; ++i) {
        while(head <= tail && q[tail].value <= a[i]) --tail;
        q[++tail].value = a[i];
        q[tail].id = i;
        while(q[head].id < i - m + 1) ++head;
        mx[i] = q[head].value;
    }
}

int main() {
    read(n); read(m);
    for(int i = 1; i <= n; ++i) read(a[i]);
    getmin();
    getmax();
    for(int i = m; i <= n; ++i) 
        write(mn[i]),putchar(' ');
    putchar('
');
    for(int i = m; i <= n; ++i) 
        write(mx[i]),putchar(' ');
    return (0^_^0);
}