單調佇列，顧名思義，維護的佇列中的資料是呈單調遞增或者單調遞減的，在維護單調佇列時，例如單調遞增佇列，當有新的資料入隊，則從隊尾開始，把所有大於該數的專案pop出佇列，保證了這個資料入隊後整個佇列依舊是單調遞增的，一般單調佇列的實現是用一個定長陣列和變數head和tail來維護隊頭和隊尾。單調佇列一個簡單應用是定長區間的最大/最小值問題，又叫做視窗滑動，就是一個長度為k的視窗在數列上滑動，每滑動一格就要求出當前視窗內的最大值/最小值。對於這種題目，我們需要做的就是維護單調佇列，並且即時把隊頭元素所處數列位置pos小於當前視窗左端的值彈出佇列，這樣每次維護完後，單調佇列的隊頭就是當前視窗區間的最大值/最小值了。因此還需要記錄佇列中每個元素的位置。

單調佇列的應用還是很多的，可以對一些演算法進行改進已優化複雜度，例如單調佇列揹包dp，不過我都還不會= =。

單調佇列很多時候做的事跟RMQ很像，不過RMQ可以查詢不定長區間的最大最小值，不過單調佇列的複雜度更低。

詳情看題來學習吧。

1.Sliding Window POJ - 2823

應該是最經典的單調佇列的應用了，方法我上面說過了。

#include<iostream>
#include<algorithm>
#include<string.h>
#include<stdio.h>
#include<vector>
 

#include<string>
#include<cmath>
#include<set>
#include<map>
#include<queue>
using namespace std;
#define ll long long
#define inf 0x3f3f3f3f
const int mod = 1000000007;
const int maxm = 1000005;
const int maxn = 1000055;
const int M = 25;
int n, p, k;
int num[maxn];
int minn[maxn];
int
 
 maxx[maxn];
pair<int, int> que1[maxn];
pair<int, int> que2[maxn];
int main() {
    scanf("%d%d", &n, &k);
    for (int i = 0; i < n; i++){
        scanf("%d", &num[i]);
    }
    int head1 = 0,head2=0, tail1 = 0,tail2=0;
    for (int i = 0; i < n; i++){
        while (i-que1[head1].second >=k&&head1<tail1){ head1++; }
        while (tail1>head1&&num[i]>=que1[tail1 - 1].first){ tail1--; }
        que1[tail1].first = num[i], que1[tail1++].second = i;
        maxx[i] = que1[head1].first;

        while (i - que2[head2].second >= k&&head2<tail2){ head2++; }
        while (tail2 > head2&&num[i] <= que2[tail2 - 1].first){ tail2--; }
        que2[tail2].first = num[i], que2[tail2++].second = i;
        minn[i] = que2[head2].first;
    }
    for (int i = k - 1; i < n; i++){
        printf("%d", minn[i]);
        if (i < n - 1){ printf(" "); }
    }
    printf("\n");
    for (int i = k - 1; i < n; i++){
        printf("%d", maxx[i]);
        if (i < n - 1){ printf(" "); }
    }
    return 0;
}

2.Subsequence HDU - 3530

題目要求我們找到一個最大的子序列，使得序列中的最大值減去最小值大於等於m且小於等於k，樸素的做法我們就應該列舉每一個點i作為子序列的末尾，然後往前遍歷維護最大值和最小值，來尋找滿足條件的最左端，不過n^2的複雜度會超時，這時我們就可以選擇使用兩個單調佇列來維護最大值和最小值，首先，如果遞減單調佇列的值減去遞增單調佇列的值大於k，那麼使i作為最右端的滿足條件的序列的最左端肯定在兩個隊頭所處位置左者的右邊，列舉到後面的i作為右端時也如此，所以這裡彈出隊頭是不會影響後續處理的，通過維護單調佇列和最左端pre，我們就可以找到滿足最大值和最小值差<=k的子序列，這時就可以判斷是否大於等於m來更新答案。

#include<iostream>
#include<algorithm>
#include<string.h>
#include<stdio.h>
#include<vector>
#include<string>
#include<cmath>
#include<set>
#include<map>
#include<queue>
using namespace std;
#define ll long long
#define inf 0x3f3f3f3f
const int mod = 1000000007;
const int maxm = 1000005;
const int maxn = 100005;
const int M = 25;
int n, m, k;
int num[maxn];
int que1[maxn], que2[maxn];

int main() {
    int x;
    while (~scanf("%d%d%d", &n, &m, &k)){
        for (int i = 0; i < n; i++){
            scanf("%d", &num[i]);
        }
        int ans = 0;
        int pre = 0;
        int head1 = 0, tail1 = 0,head2=0,tail2=0;
        for (int i = 0; i < n; i++){
            while (head1 < tail1&&num[i] > num[que1[tail1 - 1]])tail1--;
            while (head2 < tail2&&num[i] < num[que2[tail2 - 1]])tail2--;
            que1[tail1++] = i;
            que2[tail2++] = i;
            while (head1 < tail1&&head2<tail2&&num[que1[head1]] - num[que2[head2]]>k){
                if (que1[head1] < que2[head2]){ pre = que1[head1++] + 1; }
                else{ pre = que2[head2++] + 1; }
            }
            if (head1 < tail1&&head2 < tail2&&num[que1[head1]] - num[que2[head2]] >= m){
                ans = max(ans, i - pre + 1);
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

3.Beans HDU - 2430

題目簡單來講就是找一個子序列，使得（序列數值和%P<=K）且（數值和/P)最大，我們先處理出1-i（i=1,2,3…）的數值和sum[i]和模p後的值a[i]，對於每一個a[i]，若a[i]<=k，則1-i這段子序列是滿足條件的，否則，我們需要從1~i-1之間需要一個a[j]，使得a[i]-a[j]<=k,樸素做法也就是遍歷搜尋，不過同上面的題一樣，可以使用單調佇列來完成，將a[i]從小到大的列舉，維護一個模值單調遞增且相同模值時位置單調遞增的單調佇列，對於每個a[i],不斷彈出隊頭使得隊頭的模值a[que[head]]滿足a[i]減去它小於等於k，就可以更新答案，可以證明這一定是滿足調減的最左端（因為按位置排序了）並且彈出的隊頭對後面的處理無影響（因為列舉的a[i]是單調遞增）.

#include<iostream>
#include<algorithm>
#include<string.h>
#include<stdio.h>
#include<vector>
#include<string>
#include<cmath>
#include<set>
#include<map>
#include<queue>
using namespace std;
#define ll long long
#define inf 0x3f3f3f3f
const int mod = 1000000007;
const int maxm = 1000005;
const int maxn = 1000500;
const int M = 25;
int n, p, k;

struct pp{
    int pos, num;
}a[maxm],b[maxm];
ll sum[maxn];

bool cmp(pp a, pp b){
    if (a.num == b.num)return a.pos < b.pos;
    return a.num < b.num;
}

int main() {
    int t,x;
    scanf("%d", &t);
    for (int cas = 1; cas <= t; cas++){
        scanf("%d%d%d", &n, &p, &k);
        for (int i = 1; i <= n; i++){
            scanf("%d", &x);
            sum[i] = sum[i - 1] + x;
            a[i].num = sum[i] % p;
            a[i].pos = i;
        }
        sort(a + 1, a + n + 1, cmp);
        int head = 0, tail = 0;
        ll ans = -1;
        for (int i = 1; i <= n; i++){
            while (tail > head&&a[i].pos < b[tail-1].pos){ tail--; }
            b[tail++] = a[i];
            while (head<tail&&a[i].num - b[head].num>k){ head++; }
            if (a[i].num <= k){ ans = max(ans, sum[a[i].pos]/p); continue; }
            if (b[head].pos<a[i].pos&&head<tail){ ans = max(ans, (sum[a[i].pos] - sum[b[head].pos])/p); }
        }
        printf("Case %d: %lld\n", cas, ans);
    }
    return 0;
}

剛學習這個，理解還不是很深刻， 題目有點變形就反應不過來了，講解也講不了很清楚，有待深入學習。