单调栈和单调队列的关系
单调栈和单调队列的本质，顾名思义，就是单调：利用单调性来解决一些问题。
由于所有元素只会入栈/队1次，所以其复杂度为O(n)
单调队列是单调栈的升级版
单调栈
单调栈就是一个栈，栈中元素有单调的特性。我们向栈中加入元素时，依照单调性，弹出加入新元素后不符合单调性的元素，从而维护栈的单调。
举个例子 单调栈S：1 2 4 9 想要加入的元素是 3
那么我们先弹出 9 再弹出 4 最后把 3 加在栈顶，一个操作就完成了
这时 S：1 2 3 维护了其单调性
那么利用单调栈可以解决什么问题呢？
P1901 发射站
题目描述
某地有 N 个能量发射站排成一行，每个发射站 i 都有不相同的高度 Hi，并能向两边（当 然两端的只能向一边）同时发射能量值为 Vi 的能量，并且发出的能量只被两边最近的且比 它高的发射站接收。
显然，每个发射站发来的能量有可能被 0 或 1 或 2 个其他发射站所接受，特别是为了安 全，每个发射站接收到的能量总和是我们很关心的问题。由于数据很多，现只需要你帮忙计 算出接收最多能量的发射站接收的能量是多少。
输入输出格式
输入格式：
第 1 行：一个整数 N;
第 2 到 N+1 行：第 i+1 行有两个整数 Hi 和 Vi，表示第 i 个人发射站的高度和发射的能量值。
输出格式：
输出仅一行，表示接收最多能量的发射站接收到的能量值，答案不超过 longint。
分析一下数据范围：我们发现只有O(n)的复杂度才可以过这题
因为能量只能被最近的比他高的雷达站吸收，所以我们构建一个单调栈：对于每一个信号塔（元素），它发射的电波能被最近的比他高的接受，所以加入这个信号塔（元素）入栈时，弹出高度比他小的（因为弹出的矮，起码比新信号塔矮，所以有能量也只会传到新元素，至少不会是它，所以我们可以将其弹出），完成弹出之后，将能量加到第一个比他高的（也就是此时的栈顶），最后将新元素加到栈里，这次操作就完成了
对于这题，要从左到右，从右到左做两遍，具体依照题意
#include<iostream>
#include<cstdio>
#include<algorithm>
#define ll long long
using namespace std;
int RD(){
int out = 0,flag = 1;char c = getchar();
while(c < '0' || c >'9'){if(c == '-')flag = -1;c = getchar();}
while(c >= '0' && c <= '9'){out = out * 10 + c - '0';c = getchar();}
return flag * out;
}
const int maxn = 10010010;
int num;
ll sum[maxn];
struct S{int h;int v;}I[maxn];
struct Que{int index,h;}que[maxn];
void getmax(){//做两遍单调栈累计能量
int tail = 0;
for(int i = 1;i <= num;i++){
while(tail > 0 && I[i].h >= que[tail].h)tail--;
if(tail != 0){
sum[que[tail].index] += I[i].v;
}
que[++tail].h = I[i].h;
que[tail].index = i;
}
}
void getanothermax(){
int tail = 0;
for(int i = num;i >= 1;i--){
while(tail > 0 && I[i].h >= que[tail].h)tail--;
if(tail != 0){
sum[que[tail].index] += I[i].v;
}
que[++tail].h = I[i].h;
que[tail].index = i;
}
}
int main(){
num = RD();
for(int i = 1;i <= num;i++){
I[i].h = RD();
I[i].v = RD();
}
getmax();
getanothermax();
ll ans = -1;
for(int i = 1;i <= num;i++){
ans = max(ans,sum[i]);
}
cout<<ans<<endl;
return 0;
}
单调队列
前面提到过，单调队列是单调栈的升级版。单调队列是有限制的单调栈。
试想向一个队列里加入元素：元素的加入除了大小关系，肯定有先后之分。若题意要求我们按一定规则弹出旧元素，这时我们就得用到单调队列了。
比如说最典型的问题：区间长度确定的最值求解问题
P2032 扫描
题目描述
有一个 1 ∗ n 的矩阵，有 n 个正整数。
现在给你一个可以盖住连续的 k 的数的木板。
一开始木板盖住了矩阵的第 1 ∼ k 个数，每次将木板向右移动一个单位，直到右端与
第 n 个数重合。
每次移动前输出被覆盖住的最大的数是多少。
输入输出格式
输入格式：
从 scan.in 中输入数据
第一行两个数，n，k，表示共有 n 个数，木板可以盖住 k 个数。
第二行 n 个数，表示矩阵中的元素。
输出格式：
输出到 scan.out 中
共 n − k + 1 行，每行一个正整数。
第 i 行表示第 i ∼ i + k − 1 个数中最大值是多少。
直接是区间最值得模板
因为题意需要我们弹出比较旧的元素，所以我们给每个元素除了值之外的另一个属性：序号
队尾加入新元素操作与单调栈相同，升级了的是：在每次新元素插入后，利用元素的序号判断队首元素是否需要弹出
以这题为例：每次加入新的元素（方法同单调栈），然后判断队首是否应该被弹出（若新元素的序号 - 队首的序号 > k 则弹出）
（注意，不同的题目的弹出队首方法依题意不同，具体请审题）
通过分析可以看到：这里的单调队列并不是一个真的队列，他可以双头弹出，是个双端队列（不过这里没用到其全部功能，双端队列可以将元素插到队首），是可以用来玄学优化SPFA的，并且有STL里的deque可以实现，这里就不加赘述了。
#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
int RD(){
int out = 0,flag = 1;char c = getchar();
while(c < '0' || c >'9'){if(c == '-')flag = -1;c = getchar();}
while(c >= '0' && c <= '9'){out = out * 10 + c - '0';c = getchar();}
return flag * out;
}
const int maxn = 2000100;
struct MAX{int index,v;}que[maxn];
int a[maxn];
int num,k;
void getmax(){
int head = 1,tail = 0;
for(int i = 1;i <= k;i++){
while(head <= tail && a[i] >= que[tail].v)tail--;
que[++tail].v = a[i];//赋值
que[tail].index = i;//给与其序号
}
for(int i = k + 1;i <= num;i++){
printf("%d
",que[head].v);
while(head <= tail && a[i] >= que[tail].v)tail--;//操作同单调栈
que[++tail].v = a[i];
que[tail].index = i;
while(que[head].index <= i - k)head++;//是否弹出队首
}
printf("%d
",que[head].v);
}
int main(){
num = RD();k = RD();
for(int i = 1;i <= num;i++)a[i] = RD();
getmax();
return 0;
}
类似的题目还有
P1440 求m区间内的最小值
P3088 [USACO13NOV]挤奶牛Crowded Cows
P2251 质量检测
P2947 [USACO09MAR]向右看齐Look Up
带有技巧的单调队列
有些题目单用单调队列是不能解决问题的，看这一题:
P1714 切蛋糕
题目描述
今天是小Z的生日，同学们为他带来了一块蛋糕。这块蛋糕是一个长方体，被用不同色彩分成了N个相同的小块，每小块都有对应的幸运值。
小Z作为寿星，自然希望吃到的第一块蛋糕的幸运值总和最大，但小Z最多又只能吃M小块(M≤N)的蛋糕。
吃东西自然就不想思考了，于是小Z把这个任务扔给了学OI的你，请你帮他从这N小块中找出连续的k块蛋糕(k≤M)，使得其上的幸运值最大。
输入输出格式
输入格式：
输入文件cake.in的第一行是两个整数N,M。分别代表共有N小块蛋糕，小Z最多只能吃M小块。
第二行用空格隔开的N个整数，第i个整数Pi代表第i小块蛋糕的幸运值。
输出格式：
输出文件cake.out只有一行，一个整数，为小Z能够得到的最大幸运值。
这是一道好题（认真脸）
刚开始看的时候，觉得一个单调队列就可以解决了，后来死活过不了样例，再仔细看题发现：是最多吃M块蛋糕，考虑到蛋糕有负的幸运值，吃完M块不一定就是幸运值最大的方案。
那么怎么办呢？
思考一下，怎么样才能得到Fmax呢？我们可以预处理一下前缀和：sum[1] ~ sum[n]，因为对于某块蛋糕来说，其前缀和是固定的，那么Fmax不就等于sum[i] - (不超过范围，满足M块这一条件的)sum[j]min了吗？
然后就开始明朗的：利用前缀和的思想求解前缀和，再利用单调队列求某一区间内前缀和的最小值，相减即为本次的答案，对于每块蛋糕都有一个不超过M块的最大值，每次更新一下求最大的最大就行了
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int RD(){
int flag = 1,out = 0;char c;c = getchar();
while(c < '0' || c > '9'){if(c == '-')flag = -1;c = getchar();}
while(c >= '0' && c <= '9'){out = out * 10 + c - '0';c = getchar();}
return flag * out;
}
const int maxn = 500100;
struct Que{int index,v;}que[maxn];
int num,a[maxn],k;
int ans = -999999999;
void getmax(){
int head = 1,tail = 0;
for(int i = 1;i <= num;i++){
while(head <= tail && a[i] <= que[tail].v)tail--;
que[++tail].v = a[i];
que[tail].index = i;
while(i - k > que[head].index)head++;
ans = max(ans,a[i] - que[head].v);//队首元素的值即为区间最小值
}
}
int main(){
num = RD();k = RD();
int temp;
for(int i = 1;i <= num;i++){
temp = RD();
a[i] = a[i - 1] + temp;
}
getmax();
cout<<ans<<endl;
return 0;
}