WINDOW（单调队列的应用）

给你一个长度为 N 的数组，一个长为 K 的滑动的窗体从最左移至最右端，
你只能见到窗口的K个数，每次窗体向右移动一位，如下表：

你的任务是找出窗口在各位置时的 max value,min value.

INPUT：

第 1 行 n,k,

20%：n<=500;　　
50%:  n<=100000;
100%:  n<=1000000;
第 2 行为长度为 n 的数组

8 3
1 3 -1 -3 5 3 6 7

OUTPUT：

2 行，
第 1 行每个位置的 min value,
第 2 行每个位置的 max value

-1 -3 -3 -3 3 3
3 3 5 5 6 7

题解：

如果每次都要sort的话，小数据可以O（n*k），但是数据大的话一定会超时。

那么该如何搞呢？　　单调队列。O（n）效率很高！！

单调队列，一个元素单调的队列，可以保证队头是最小（最大）的；

可以通过队首删除，队尾插入来维护最优值。

这道题，就是通过单调队列来维护一个最大值和最小值。

代码：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
#include<cstdlib>
#include<iomanip>
#include<ctime>
using namespace std;
const int maxn=5000001;
int n,k;
int a[maxn],q[maxn];
int tail=0,head=0;

int main()
{
    cin>>n>>k;
    for(int i=1;i<=n;i++)
        cin>>a[i];
    q[tail]=1;
    for(int i=2;i<k;i++)
    {
        while(a[i]<a[q[tail]]&&tail>=head)
        {
            tail--;
        }
        q[++tail]=i;
    }
    for(int i=k;i<=n;i++)
    {
        if(i-q[head]==k)    head++;
        while(a[i]<a[q[tail]]&&tail>=head)
        {
            tail--;
        }
        q[++tail]=i;
        cout<<a[q[head]]<<" ";
    }
    cout<<endl;
    memset(q,0,sizeof(q));
    head=0,tail=0;
    q[tail]=1;
    for(int i=2;i<k;i++)
    {
        while(a[i]>a[q[tail]]&&tail>=head)
        {
            tail--;
        }
        q[++tail]=i;
    }
    for(int i=k;i<=n;i++)
    {
        if(i-q[head]==k)    head++;
        while(a[i]>a[q[tail]]&&tail>=head)
        {
            tail--;
        }
        q[++tail]=i;
        cout<<a[q[head]]<<" ";
    }
    cout<<endl;
    return 0;
}