单调队列基本知识

现在有一个数列{An}，假设它有n项，问题是：求出每个区间长度为k的连续区间内数列的最小值。

有种很容易想到的解法：

遍历每个所求区间，依次找出它们的最小值。复杂度为O( (n-k)*k )

分析上面的解法我们不难发现，在找最小值时，我们做了很多重复的比较。这样的做法无疑使复杂度变大，有没有一个好的办法可以不要做这些重复比较呢？

于是，引出了我们本文的主角：单调队列。

单调队列是这样一个队列：队内的元素单调递增（或递减，下文以递增为例），且队内后面元素的位置必须大于前面元素的位置（此处位置是指在原数列中的位置）。

1、入队时，从队尾向前扫描，直到找到队内某个元素小于它，把它放在这个元素的后面，将它作为队尾，即删除队内比它大的所有元素。

为什么可以这样删除呢？因为这个元素比所要删除的元素具有更优的性质。

何来更优？

首先，它入队比所要删除的元素晚，证明它的位置一定大于所要删除元素的位置，根据这一点，我们可以推出：

在以后的选择中，当所要删除元素的位置在所要找的区间时，它也一定在所要找的区间内。

而它又比所要删除元素小，所以它一定比所要删除元素更优。

所以它的入队意味着所要删除的元素已经失去了价值，故可以删除。

2、出队时，如果队首元素的位置不在所要找的区间内，那么就把下个元素作为队首，即删除原队列的队首。

值得一提的是，此时下个元素一定在所要找的区间内。

假设上次查找的区间为[a,a+k-1]，那么经过上次出队后，队首元素的位置最坏情况下是a，那么它后面的元素的位置一定满足p>=a+1，

所以它后面的元素一定在这次要找的区间[a+1,a+k]中。

思想明白了以后，代码应该很好写吧。

我们只需要一个长度为n的数组来记录当前队列中元素的位置就可以了，（至于为什么是n，因为最坏情况下，原数列单调递增，此时要删除n-1个元素的队首。）

而元素的值可以通过记录的位置在原数列中找到。

好了，就写到这里吧。如有纰漏，欢迎指正。

上文来自：http://blog.csdn.net/dgq8211/article/details/7430726

单调队列是指：队列中元素之间的关系具有单调性，而且，队首和队尾都可以进行出队操作，只有队尾可以进行入队操作。

以单调不减队列为例：队列内的元素（e1，e2，e3...en）存在（e1<=e2<=e3<=...<=en）的关系，所以队首元素e1一定是最小的元素。与优先队列不同的是，当有一个新的元素e入队时，先要将队尾的所有大于e的元素弹出，以保证单调性，再让元素e入队尾。

例如这样一组数（1，3，2，1，5，6），进入单调不减队列的过程如下：

1入队，得到队列（1）；

3入队，得到队列（1，3）；

2入队，这时，队尾的的元素3>2，将3从队尾弹出，新的队尾元素1<2，不用弹出，将2入队，得到队列（1，2）；

1入队，2>1，将2从队尾弹出，得到队列（1，1）；

5入队，得到队列（1，1，5）；

6入队，得到队列（1，1，5，6）；

代码实现：

[cpp] view plaincopyprint?

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class MonotonicQueue  
6. {  
7.   
8. #define MAXN 1000000  
9.   
10. public:  
11.     MonotonicQueue(void)  
12.     {  
13.         q = new int[MAXN+5];  
14.         f = r = 0;  
15.     }  
16.     void push(const int val)  
17.     {  
18.         while (r > f && q[r-1] > val) //弹出大于新元素的队尾元素  
19.         {  
20.             r--;  
21.         }  
22.         q[r++] = val;  
23.     }  
24.     int front(void)  
25.     {  
26.         if (f < r)  
27.         {  
28.             return q[f];  
29.         }  
30.         return 0;  
31.     }  
32.     void pop_front(void)  
33.     {  
34.         if (f < r)  
35.         {  
36.             f++;  
37.         }  
38.     }  
39.     bool isEmpty(void)  
40.     {  
41.         return f == r;  
42.     }  
43.     void clear(void)  
44.     {  
45.         f = r = 0;  
46.     }  
47.     ~MonotonicQueue(void)  
48.     {  
49.         delete q;  
50.     }  
51. private:  
52.     int *q;  
53.     int f;  
54.     int r;  
55. };  
56.   
57. int main(void)  
58. {  
59.     MonotonicQueue mq;  
60.     int n;  
61.     while (cin >> n)  
62.     {  
63.         int i;  
64.         for (i = 0; i < n; i++)  
65.         {  
66.             int a;  
67.             cin >> a;  
68.             mq.push(a);  
69.         }  
70.   
71.         while (!mq.isEmpty())  
72.         {  
73.             cout << mq.front() << endl;  
74.             mq.pop_front();  
75.         }  
76.         mq.clear();  
77.     }  
78.     return 0;  
79. }  

访问队首和删除队首元素的时间复杂度为O(1)，在队尾加入元素的最坏情况下的时间复杂度为O(n)，n为队列当前长度。所以，可以采用二分查找，来确定新加入元素应该插入的位置。

上文来自：http://blog.csdn.net/code_pang/article/details/14104151