【暖*墟】 #队列# 单调队列：子段最大值 + 最大子序和

STL 中队列的使用(queue)

一．基本操作：

push(x) 将x压入队列的末端  //不能push_back

pop() 弹出队列的第一个元素(队顶元素)，注意此函数并不返回任何值

front() 返回第一个元素(队顶元素)

back() 返回最后被压入的元素(队尾元素)

empty() 当队列为空时，返回true

size() 返回队列的长度

头文件：#include <queue>

声明方法: 1、普通声明 queue<int>q;

2、结构体 struct node{ int x, y; };  queue<node>q;

二．STL 中优先队列的使用方法(priority_queue)

优先队列容器与队列一样，只能从队尾插入元素，从队首删除元素。

但是它有一个特性，就是队列中最大的元素总是位于队首，

所以出队时，并非按照先进先出的原则进行，而是将当前队列中最大的元素出队。

这点类似于给队列里的元素进行了由大互小的顺序排序。

元素的比较规则默认按元素值由大到小排序，可以重载“<”操作符来重新定义比较规则。　　

基本操作：empty() 如果队列为空返回真

pop() 删除对顶元素  push() 加入一个元素

top() 返回优先队列对顶元素

在默认的优先队列中，优先级高的先出队。

在默认的int型中先出队的为较大的数。

头文件：#include <queue>

1.普通方法：priority_queue<int>q;  //通过操作，按照元素从大到小的顺序出队

priority_queue<int,vector<int>,greater<int> >q; 

//通过操作，按照元素从小到大的顺序出队

2、自定义优先级： priority_queue<int, vector<int>, cmp>q; //定义方法

//其中，第二个参数为容器类型。第三个参数为比较函数。

 

单调队列

即所有在队列里的数都必须按递增（或递减）的顺序列队的队列。

用法：在决策队列中，及时排除一定不是最优解的选择。

【例题1】（来源：caioj 1172）[ 子段最大值---单调递减队列 ]

给定一个n个数的数列，从左至右输出每个长度为m的数列段内的最大数。

解法1*** 如果按照常规方法，我们在求f[i]即i~i+m-1区间内的最值时，

要把区间内的所有数都访问一遍，时间复杂度约为O（nm）。

解法2*** 上个算法找当前的f(i)的时候，i的前面k-1个数其它在算f(i-1)的时候我们就比较过了。

保存上一次的结果？当然主要是保存i的前k-1个数中的最大值了。要用到单调递减队列。

使用单调队列就涉及到去头和删尾***

1、队列的头一定是在一段时间前就加入了队列，现在的队列头会不会离开了我们处理的区间呢？

如果它离我们正在处理的i太远了，我们就要把它去掉，去除冗杂的信息。

2、为了保证队列的递减性，在从列队尾新插入元素v时，要考虑队列尾的值是否大于v，

如果是，队列呈现 队列尾-1的值 > 队列尾的值 > v ，此时队列递减性没有消失；

如果不是，队列呈现 队列尾-1的值 > 队列尾的值 < v ，队列递减性被打破。

为了维护递减性，我们做如下考虑：v是最新值，它的位置是目前最靠后的，

它可成为以后的最大值，必须留下；队列尾-1的值与v大小不定，不能冒然删去它；

队列尾的值夹在v和队列尾-1之间，它不但不是最大值，对于以后的情况又不如v优，

因为v相比队列尾更靠后（v可以影响到后m个值，队列尾只能影响到从它的位置往后数m-1个值），

而且值更大，所以删队列尾是必定的。

の 在维护好一个 区间正确、严格递减 的单调递减队列后，队列头就是当前区间的最大值了。

#include <cmath>
#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
using namespace std;
typedef long long ll;

/*【caioj 1172】单调队列找max
给定一个n个数的数列，从左至右输出每个长度为m的数列段内的最大数。 */

//队列中存之后有可能成为最大值的数，每次入队时，清除不可能的队头和队尾。

struct node{
    int x,p; //价值 和 位置
}list[201000];

int a[201000];

int main(){
    int n,m; scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);

    int head=1,tail=1; //手写优先队列
    list[1].x=a[1]; list[1].p=1; //初始点为1
    for(int i=2;i<=n;i++){
        while(head<=tail && list[tail].x<=a[i]) tail--; 
        //↑↑新数比前几个大，前几个不可能再成为最大值（可能不止一个）
        tail++; list[tail].x=a[i]; list[tail].p=i; //a[i]加入队尾
        while(list[head].p<i-m+1) head++; //p的作用：判断区间长度
        if(i>=m) printf("%d\n",list[head].x); //每一次的队头都是当前段最大值
        //单调递减队列：如果后方有数更大，前面就删除；所以队列一定单调递减
    }
    return 0;
}

【例题2】caioj 1173

#include <cmath>
#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
using namespace std;
typedef long long ll;

/*【caioj 1173】单调队列 [减少继承的状态]
有N个数(N<=100000)，在连续M（M<=N）个数里至少要有一个数被选择。 
求选出来数的最小总和。  */

//队列中存之后有可能成为最大值的数，每次入队时，清除不可能的队头和队尾。

struct node{
    int x,p; //价值 和 位置
}list[201000];

int a[201000],f[201000]; //f[i]选择i，且保证1~i符合题意的最小价值

int main(){
    int n,m; scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);

    int head=1,tail=1;
    list[1].x=0; list[1].p=0; //继承0位置
    for(int i=1;i<=n;i++){
        while(head<=tail && i-list[head].p>m) head++; //淘汰超出范围的队头
        f[i]=list[head].x+a[i]; //选择遇到的第一个不能删的队头,可以管理的后面的数最多
        while(head<=tail && list[tail].x>f[i]) tail--; //list中是升序序列
        tail++; list[tail].x=f[i]; list[tail].p=i;
    }
    int ans=(1<<30);
    for(int i=n-m+1;i<=n;i++) //最后一段，任选f[i]都能保证满足
        if(f[i]<ans) ans=f[i];
    printf("%d",ans);
    return 0;
}

【例题3】最大子序和  tyvj - 1305

#include <cmath>
#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
using namespace std;
typedef long long ll;

/*【最大子序和】单调队列  
输入一个长度为n的整数序列，从中找出一段不超过M的连续子序列，使得整个序列的和最大。 */

//先求出前缀和s[i]，枚举右端点i，寻找最小的s[j]对应的左端点
//最优策略集合一定是“下标位置递增，对应前缀和s也递增”的序列
//1.判断队头决策和i的距离是否超过m的范围;
//2.此时队头是右端点为i，左端点为j的最优选择;
//3.不断删除队尾决策，直到队尾对应的s值小于s[i],使i入队。
//由此，队列变成了 关于前缀和的 单调递增序列↑↑↑↑↑

/*【分析】维护一个{ 下标递增且前缀和递增 }的队列。
每一次入队一个i，就删除在i前面所有不满足“单调性”的元素，
即当i入队后，这些元素一定不如i，在i的存在下这些元素一定不会被选入最优答案集合中，
也就是类似sj<=si且j<i的元素。删除的时候直接让队尾出队即可。 */

const int MAXN = 300000 + 10;
int q[MAXN],a[MAXN],s[MAXN];

int main() {
    int n,m,ans; scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) {
        scanf("%d",a[i]);
        s[i]=a[i]+s[i-1]; //前缀和
    }
    int l=1,r=1;
    for(int i=1;i<=n;i++) { //先枚举来固定右端点，问题转化为枚举左端点
        while(l<=r&&q[l]<i-m) l++; //判断队头决策和i的距离是否超过m的范围
        ans=max(ans,s[i]-s[q[l]]); //此时队头q[l]是右端点为i的最优左端点选择
        while(l<=r&&s[q[r]]>=s[i]) r--; //核心，及时弹出[对答案贡献一定不如i]的元素
        q[++r]=i;
    }
    printf("%d", ans);
    return 0;
}

整理归纳单调队列的定义：

1、维护区间最值；
2、去除冗杂状态；
3、保持队列单调（最大值是单调递减序列，最小值是单调递增序列）；
4、最优选择在队首。

整理归纳单调队列的使用方法：

1、维护队首（对于上题就是如果你已经是当前的m个之前那你就可以被删了） ；
2、在队尾插入（每插入一个就要从队尾开始往前去除冗杂状态） ；
3、取出需要的最优解（队列头的值即是）；
4、借助最优解，得到目前所求的最优解（通常此处插入DP方程）。

单调队列的原理：

在处理f[i]时，去除冗杂、多余的状态，使得每个状态在队列中只会出现一次；

同时维护一个能瞬间得出最优解的队列，减少重新访问的时间；

在取得自己所需的值后，为后续的求解做好准备。