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=;
 int n,k;
 int a[maxn],q[maxn];
 int tail=,head=;

 int main()
 {
     cin>>n>>k;
     for(int i=;i<=n;i++)
         cin>>a[i];
     q[tail]=;
     for(int i=;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,,sizeof(q));
     head=,tail=;
     q[tail]=;
     for(int i=;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 ;
 }