poj 2823 Sliding Window

              http://poj.org/problem?id=2823         

       单调队列的启蒙题。                       

                                                        Sliding Window

Time Limit: 12000MS		Memory Limit: 65536K
Total Submissions: 39404		Accepted: 11680
Case Time Limit: 5000MS

Description

An array of size n ≤ 10⁶ is given to you. There is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves rightwards by one position. Following is an example:  The array is [1 3 -1 -3 5 3 6 7], and k is 3.

Window position	Minimum value	Maximum value
[1  3  -1] -3  5  3  6  7	-1	3
1 [3  -1  -3] 5  3  6  7	-3	3
1  3 [-1  -3  5] 3  6  7	-3	5
1  3  -1 [-3  5  3] 6  7	-3	5
1  3  -1  -3 [5  3  6] 7	3	6
1  3  -1  -3  5 [3  6  7]	3	7

Your task is to determine the maximum and minimum values in the sliding window at each position. 

Input

The input consists of two lines. The first line contains two integers n and k which are the lengths of the array and the sliding window. There are n integers in the second line. 

Output

There are two lines in the output. The first line gives the minimum values in the window at each position, from left to right, respectively. The second line gives the maximum values. 

Sample Input

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

Sample Output

-1 -3 -3 -3 3 3
3 3 5 5 6 7
单调队列，顾名思义就是具有单调性的队列O(∩_∩)O~，一般的队列只能从队尾入队、队首出队；为了保持单调队列的单调性，单调队列除具有这两种性质外，还可以从队尾出队。
以单增的单调队列为例，当元素t要入队时，先要从队尾依次弹出所有>=t的元素，再将t加在队尾。
举个例子，如果序列：1 3 -1 -3 10要构成单调队列，
先将元素“1”放入队列中，以初始化队列，
接着元素“3”要入队，队尾元素“1”比“3”小，因此“3”可以直接入队，队列变为1 3，
接着“-1”要入队，从队尾依次弹出元素“3”“1”后将“-1”入队，队列变为-1，
同理“-3”入队后，队列变为-3,
“10”入队后，队列变为-3 10

单调队列有什么用呢？看一道例题：（poj2823）
给定含有n个元素的无序序列a[]，和一个整数k，要求求出a[]中每连续k个元素组成的序列中的最小值（或最大值），这样的值可能有1个或n-k+1个。
比较简单的方式，是每次都将k个数排序后输出最值，具有O(N^2logN)的时间复杂度。但如果用单调队列的话，我们可以在O(N)的时间内求解，原因是每个元素最多入队一次、出队一次。
要解决该题，我们还要记录每个元素在原序列中的位置p，每次只需从队首开始找到跟当前元素a[i]距离不大于k的元素（即是i-p+1<=k）输出即可。

#include<iostream>
#include<cstdio>
using namespace std;
struct node
{
    int p;
    int num;
}q[1000005],q1[1000005];
int r,f,g,ff;
int a[1000005];
void inquene(int i)
{
    while(q[--r].num>a[i]&&r>=f);
    // printf("r1=%d
",r);
    q[++r].p=i;
   // printf("r2=%d
",r);
    q[r].num=a[i];
        r++;
    // printf("r3=%d
",r);
}
void dequene(int i)
{
   while(q1[--g].num<a[i]&&g>=ff);
      q1[++g].p=i;
     q1[g].num=a[i];
        g++;
}
int main()
{
   int n,k,i;
   while(~scanf("%d%d",&n,&k))
   {
    for(i=1;i<=n;i++)
     scanf("%d",&a[i]);
      r=g=2;f=ff=1;
     q[1].p=1;
     q[1].num=a[1];
    for(i=2;i<=k&&i<=n;i++)
     {
        inquene(i);
     }
     printf("%d",q[f].num);
     for(;i<=n;i++)
     {
         inquene(i);
         while(i-q[f].p>=k)
            f++;
       // printf("f=%d
",f);
        printf(" %d",q[f].num);
     }
     printf("
");
     q1[1].p=1;
     q1[1].num=a[1];
     for(i=2;i<=k&&i<=n;i++)
     {
        dequene(i);
     }
     printf("%d",q1[ff].num);
     for(;i<=n;i++)
     {
         dequene(i);
         while(i-q1[ff].p>=k)
            ff++;
       // printf("f=%d
",f);
        printf(" %d",q1[ff].num);
     }
     printf("
");
}
   return 0;
}