作者：hsez_yyh
链接：https://blog.youkuaiyun.com/yyh_getAC/article/details/123956399
来源：湖北省黄石二中竞赛组
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
单调队列是近几年比较热门的一种技巧(算法)，我们学习单调队列，可以类比单调栈。根据单调栈，我们可以推理出，单调队列中储存的元素和单调栈中的一样，具有单调性。但是，单调队列比单调栈多的操作就是，其能够从头部删除或添加，也可以队列尾部删除或添加。
既然是队列，那么就和我们平时排队一样，前面的人办理完业务后就离开了——也就是出队，后面的人想要办理业务就需要排队——入队，但是有的人是军人或特殊人员，就可以不需要排队——从队头插入，而大部分人需要老老实实排队——从队尾插入，当然，还有中途想离开的——从队尾弹出。以上就是对单调队列的形象解释。
我们都清楚单调队列中元素不是单调递增就是单调递减的，但是有什么用呢？
既然是浅谈，那么我们就不去讲什么单调队列优化dp这种令人头痛的东西，我们就来感受一下单调队列的妙处，让我们先看到题：
YbtOJ：最优密码
题目大意是：给出一个小写字符串S，至多进行m次操作，可以选择S中任意两个相邻的字符交换位置，求交换后字典序最小的字符串。
很显然这道题的正解是贪心+树状数组，具体思路是把最小的字符串尽量往头部放，也就是说从前往后确定每一位字母(最多m位)，从小到大的枚举字母，然后用一个树状数组来维护每个字母是否出现在前m位即可，代码如下：
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
const int N=1e5+5;
using namespace std;
int lowbit(int x)
{
return x&-x;
}
struct fenw
{
int c,exist,num,minnum,minlast;
//存在个数，存在，当前值，当前维护的最小，维护的左边最小
void query(int x,int v);
int ask(int x);
int get_rnk(int x);
int get_min(int x);
void del(int x);
}e[N],fenwick;
int n,m,num[N];
char opt[N];
void fenw::query(int x,int v)
{
for(int i=x;i<=n;i+=lowbit(i))
e[i].c+=v;
}
int fenw::ask(int x)
{
int ret=0;
for(int i=x;i;i-=lowbit(i))
ret+=e[i].c;
return ret;
}
int fenw::get_rnk(int x)
{
int l=1,r=n;
while(l<r)
{
int mid=(l+r)>>1;
if(fenwick.ask(mid)>=x)
r=mid;
else
l=mid+1;
}
return r;
}
int fenw::get_min(int x)
{
int r=x,minn=e[x].num,minleft=x,l=1;
while(r>=l)
{
if(r-lowbit(r)+1>=l)
{
if(e[r].minnum<=minn)
{
minn=e[r].minnum;
minleft=e[r].minlast;
}
r-=lowbit(r);
}
else
{
if(e[r].exist && e[r].num<=minn)
{
minn=e[r].num;
minleft=r;
}
r--;
}
}
return minleft;
}
void fenw::del(int x)
{
e[x].exist=0;
e[x].num=30;
fenwick.query(x,-1);
for(int i=x;i<=n;i+=lowbit(i))
{
e[i].minnum=e[i].num;
e[i].minlast=i;
int len=lowbit(i);
for(int j=1;j<len;j<<=1)
if(e[i].minnum>=e[i-j].minnum)
{
e[i].minnum=e[i-j].minnum;
e[i].minlast=e[i-j].minlast;
}
}
}
int main()
{
scanf("%d %s",&m,opt+1);
n=strlen(opt+1);
for(int i=1;i<=n;i++)
{
num[i]=opt[i]-'a'+1;
e[i].c=1;
e[i].exist=1;
e[i].num=num[i];
e[i].minlast=i;
e[i].minnum=num[i];
int len=lowbit(i);
for(int j=1;j<len;j<<=1)
{
e[i].c+=e[i-j].c;
if(e[i].minnum>=e[i-j].minnum)
{
e[i].minnum=e[i-j].minnum;
e[i].minlast=e[i-j].minlast;
}
}
}
int now_sum=n;
while(m>0 && now_sum>0)
{
int id=fenwick.get_rnk(min(m+1,now_sum));
int left_min=fenwick.get_min(id);
printf("%c",e[left_min].num+'a'-1);
fenwick.del(left_min);
m-=fenwick.ask(left_min-1);
now_sum--;
}
for(int i=1;i<=n;i++)
if(e[i].exist)
printf("%c",opt[i]);
puts("");
return 0;
}
虽然树状数组的板子很好写，但是代码还是太长了，并且有人没有学过树状数组怎么办？于是我们想想有没有其他方法来最这道题。
很显然 这可以用单调队列来维护：创建26个队列，分别代表a~z，将字符串上的每一个点按位置分别放入属于自己的队列，然后我们从a开始查看每一个队列，然后就能得出结果，对于每次取出对头元素，我们就要将原来在其前面的元素的位置往后挪一个，那么怎么快速做到呢？我们为了不写树状数组，就只能分块了（如果这还不会写，真就没办法了），如此，我们就可以直接利用懒标记快速算出某个字母的位置了。当然，在代码实现时，逻辑上可能会有些绕，但是想通了就特别开朗了。代码如下：
#include<bits/stdc++.h>
using namespace std;
const int N=100010;
string s;
int m;
struct node
{
int v;
int id;
}d[N];
deque <node> q[150];
int a[N],bl[N],bb[N];
int block;
void add(int temp)
{
for(int i=1;i<bl[temp];i++)
bb[i]++;
for(int i=(bl[temp]-1)*block+1;i<temp;i++)
a[i]++;
}
int main()
{
scanf("%d",&m);
cin>>s;
int len=s.size();
for(int i=0;i<len;i++)
{
d[i+1].v=int(s[i]);
d[i+1].id=i+1;
q[d[i+1].v].push_back(d[i+1]);
}
block=sqrt(len);
for(int i=1;i<=len;i++)
bl[i]=(i-1)/block+1;
int k=0;
int p=97;
int temp=1;
int oo=0;
while(m>0)
{
for(int i=p;i<=122;i++)
{
if(q[i].empty())
continue;
else
{
node u=q[i].front();
if(u.id+bb[bl[u.id]]+a[u.id]<=m+1+k)
{
temp=u.id;
q[i].pop_front();
break;
}
}
}
printf("%c",d[temp].v);
d[temp].v=0x3f3f3f3f;
add(temp);
m=m-(temp+bb[bl[temp]]+a[temp])+1+k;
k++;
if(k>=len)
break;
}
for(int i=1;i<=len;i++)
if(d[i].v!=0x3f3f3f3f)
printf("%c",d[i].v);
return 0;
}
以上便是单调队列的写法，如此，我们可以发现，单调队列在某种程度上可以简化算法，其功能运用的好的话，会帮你砍掉一个大大的数据结构，所以在平时多想想，多思考，感受单调队列等朴素但神奇的算法的魅力，会在比赛时起到意料之外的作用。
这篇文章的目的也就是为了让大家感受到单调队列的好处，希望大家也能灵活掌握这种思维方式。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
