单调队列、优先队列
“如果一个人比你年轻还比你强，那你就要被踢出去了……”——单调队列
“来来来，神犇巨佬、金牌\(Au\)爷、\(AKer\)站在最上面，蒟蒻都靠下站！！！”——优先队列
Part 1：单调队列
单调队列的功能
顾名思义，所谓单调队列，那么其中的元素从队头到队尾一定要具有单调性（单调升、单调降等）
它被广泛地用于“滑动窗口”这一类\(RMQ\)问题，其功能是\(O(n)\)维护整个序列中长度为\(k\)的区间最大值或最小值
单调队列实现原理
滑动窗口问题
给定一个长度为\(n\)的序列\(a\)和一个窗口长度\(k\)，窗口初始覆盖了\(1\rightarrow k\)这些元素
之后窗口每次向右移一个单位，即从覆盖\(1\rightarrow k\)变成覆盖\(2\rightarrow k+1\)
要求求出每次移动（包括初始时）窗口所覆盖的元素中的最大值（如图，花括号内即为被窗口覆盖的元素）
数据范围：\(1\leq k\leq n\leq 10^6,a_i\in[-2^{31},2^{31})\)
\(Solution\) \(1：\)暴力碾标算\(O(nk)\)
“越接近暴力的数据结构，能维护的东西就越多”——真理
线段树和树状数组维护不了众数，但分块可以。你再看暴力，它什么都能维护……
很简单，每次从窗口最左端扫到最右端，然后取最大值就\(OK\)了
显然在这种数据强度下暴力是过不了的，代码就不给了
\(Solution\) \(2：\)单调队列\(O(n)\)
思考暴力为什么慢了：因为窗口每次才移动\(1\)个单位，但是暴力算法每次都重复统计了\(k-2\)个元素
那我们把中间那一大堆数的最大值记录下来，每次进来一个元素，出去一个元素，统计一下最值，这不就快了吗？
但是，不幸的是，如果出去的那个元素正好是最值，那就得重新统计了
考虑维护一个单调不升队列，每次新元素进来之前，从这个队列的最小值向最大值依次比较
如果这个队列中的一个数\(a\)没有新来的那个元素\(b\)大，那么把\(a\)踢出序列
因为\(a\)一定在新来的数之前出现，它的值没有\(b\)大，所以在之后的统计中\(a\)永远也不可能成为最大值，就没必要记录\(a\)了
处理完新元素，现在看看旧元素怎么处理：
一个数\(a\)如果不在窗口里，那么需要把它踢出这个队列，但是如果我们每次移动都要找到这个\(a\)再踢出，那么复杂度又变成了\(O(nk)\)，显然不行
发现新元素不受旧元素的影响，每次一定会进入到队列里，不会因为旧元素而把新元素卡掉，而且我们只是查询最大值，所以没有必要严格维护序列里每个值都在窗口里，只要保证最大值出自窗口里即可
因为这个队列单调不升，所以队头一定是我们要查询的最大值，那么我们可以对队头扫描，如果这个队头在窗口之外，把这个队头踢出去，新的队头是原来的第二个元素
重复上述操作，直到队头在窗口里即可，因为序列单调不升，所以队头一定是窗口内的最大值
以上就是单调队列算法的全部内容
复杂度分析
有些刚学的同学，看到循环\(n\)重嵌套，马上来一句：这个算法的复杂度是\(O(n^n)\) 的，这是不对的！！！
比如刚才我们的这个算法，看似每次窗口移动时都要对整个单调队列进行扫描，但是，从总体来看，每个元素只会入队一次，出队一次，所以复杂度是\(O(n)\)的
核心\(Code\)
struct Node{
int num,und;//num是值,und是下标
Node(){}
}q[1e6+10];
int main(){
int i,head=1,tail=0;//建立单调队列维护k个数中最大值,head是队头,tail是队尾
for(i=1;i<k;i++){//先把k个元素都进来
while(head<=tial&&q[tail].num<a[i]) tail--;//如果队尾没有新元素大,那么在之后的统计中,它永远不可能成为最大值,踢出
q[++tail].und=i,q[tail].num=a[i];//新元素插入队尾
}
for(;i<=n;i++){
while(head<=tail&&q[tial].num<a[i]) tail--;
q[++tail].und=i,q[tail].num=a[i];
while(q[head].und<i-k+1) head++;//队头过时了,踢出
ans[i]=q[head].num;//统计答案
}
}
\(\text{Upd:2023.10.10}\) 更新一版封装好的，写的也简单一点（上面那个刚学 OI 的时候搞的，有点屎山）。
class Data
{
public:
int num, it;
Data(int a, int b) : num(a), it(b){}
};
class Monotonic_queues
{
public:
Monotonic_queues() : cnt(0) {}
inline void PushBack(const int x)
{
cnt ++;
while(Q.size() && Q.back().num < x)
Q.pop_back();
//从队尾开始 pop 掉比 x 小的元素，因为这些元素又小又老
Q.push_back( Data(x, cnt) );
}
inline int Front(const int tme)
{
//参数 tme 为时间戳，检查元素是否过时
while(Q.size() && Q.front().it < tme)
Q.pop_front();
return Q.front().num;
}
private:
int cnt;
deque< Data > Q;
};
Part 2：优先队列
一个悲伤的故事背景：
从前，NOI系列比赛禁止使用\(C++STL\)时，优先队列是每一个\(OI\)选手一定会熟练手写的数据结构。
但是自从\(STL\)盛行，会手写优先队列的选手越来越少了……传统手艺没有人继承，真是世风日下（STL真香）啊……
优先队列的功能
优先队列有另一个名字：二叉堆
功能是维护一堆数的最大值（大根堆）/最小值（小根堆），存放在堆顶（也就是根）
注意：凡是\(STL\)都自带常数
优先队列实现原理
没错，实现原理就是\(C++STL\)
\(C++STL\)中\(#include<queue>\)头文件为我们提供了一个免费的优先队列——\(priority\)_\(queue\)，但是不支持随机删除，只支持删除堆顶
优先队列的声明和操作方法
声明方法
std::priority_queue<int>Q;
上面就声明了一个\(int\)类型的大根堆，想要一个小根堆？没关系，你可以这么写：
std::priority_queue< int,std::vector<int>,std::greater<int> >Q;
或者把每个数入堆时都取相反数，然后在用的时候再取相反数
对于结构体，我们还有更骚的操作：重载小于号运算符
struct Node{
int x,y;
Node(){}
}
bool operator < (const Node a,const Node b){ return a.x<b.x; }
std::priority_queue<Node>Q;
这样就是按照\(x\)大小比较的大根堆，如果你想要小根堆，那么把重载运算符改成这句：
bool operator < (const Node a,const Node b){ return a.x>b.x; }
这样，系统就会认为小的更大，所以小的就会跑到堆顶去
但是，如你想要\(int\)类型的小根堆，千万不要重载运算符，这样普通的两个\(int\)数就不能正常比较了（系统会认为小的更大）
常用操作命令
//std priority_queue 操作命令
Q.push();//插入元素，复杂度O(logn)
Q.pop();//弹出堆顶，复杂度O(logn)
Q.size();//返回堆中元素个数，复杂度O(1)
Q.top();//返回堆顶元素，复杂度O(1)
奇技淫巧
什么？你想让\(priority\)_\(queue\)支持随机删除，但是又不想手写？（那你可真是懒
但是这能难倒人类智慧吗？显然不能，这里有一个玄学的延迟删除法，可以满足需求
我们可以维护另一个优先队列（删除堆），每次要删除一个数（假设为\(x\)）
当需要删除\(x\)的时候，我们并不去真正的堆里面删除\(x\)，而是把\(x\)加入删除堆
访问维护最值的堆时，看看堆顶是不是和删除堆堆顶一样，如果一样，说明这个数已经被删掉了，在原堆和删除堆中同时\(pop\)掉
这个方法为什么对呢？万一原堆的堆顶\(x\)已经被删了，而删除堆的堆顶不是\(x\)，导致找到了错的最值，怎么办呢？
其实这种情况不可能出现。假设我们维护了一个大根堆，如果删除堆的堆顶不是\(x\)，那必然是一个比\(x\)大的数\(y\)
如果\(y\)还没有被删除，那么比\(y\)小的\(x\)一定还不是堆顶，几次弹出后，堆顶是\(y\)，发现删除堆堆顶同样是\(y\)，\(y\)从原堆和删除堆中删除
换句话说，当原堆的堆顶是\(x\)时，删除堆堆顶和原堆中还需要删除的数一定\(\leq x\)，所以不会找到错误的最值
