单调队列算法总结&专题训练

一些 update

update 2021/2/28：修改了『概述』部分。

1.概述

单调队列是一种特殊的队列，其保证队列内的元素单调递增。

而单调队列通常解决的是这样一类问题：

有 $n$ 个数，给定长度 $len$，求所有区间 $[k,k+len](k+len\le n,k\in [1,n],k\in N)$ 的最大最小值。

确实这个可以用 st 表，线段树之类的做，但是带一个 log。

而单调队列可以 $O(n)$ 实现。

2.模板

以这道模板题为例，讲述单调队列的用法。link

手造一组样例（与例题所给略有不同）：（$n=8,k=3$）

1 3 -1 -3 5 6 7 7

以求最小值为例，建立一个双端队列。

循环 $i$ 从 1 到 $n$ 。

$i=1$ 时，队列为空，插入 $a_1$ 。

队列： 1 ，最小值为 1 。

$i=2$ 时，$a_2=3$，比 队首元素 要大，难道我们就要残忍抛弃 $a_2$ 吗?

不能！ 虽然 $a_2>a_1$ ，但是随着时间的推移， $a_1$ 会 首先被挤出队列，对后面不能做出贡献，但是 $a_2$ 活得更久 呆在队列里的时间更长，在 $a_1$ 离开之后就有可能成为答案，所以我们要将 $a_2$ 插入队列。（以上为单调队列一个重要思想）

队列： 1 3，最小值为 1 。

$i=3$ 时，$a_3=-1$，比前面的数都小，并且 $a_3$呆在队列里的时间比 $a_1,a_2$ 更长，肯定比 $a_1,a_2$ 更优，那么要 $a_1,a_2$有什么用？从队尾弹出 $a_1,a_2$（这就是为什么要用双端队列而不是普通队列），插入 $a_3$ 。（以上为单调队列另一个重要思想）

所以发现了吗？我们其实是要在队列里面维护一个单调递增序列。

队列：-1，最小值为 -1。

$i=4$ 时， $a_4>队尾元素$ ，根据 $i=3$ 的推论，弹出 $a_3$ ，插入 $a_4$。

队列：-3 ，最小值为 -3 。

$i=5$ 时， $a_5>队尾元素$ ，根据 $i=2$ 的推论，插入 $a_5$。

队列：-3 5。

$i=6$ 时，$a_6>队尾元素$ ，根据 $i=2$ 的推论，插入 $a_6$。

队列：-3 5 6，最小值 -3。

$i=7$ 时，$a_7>队尾元素$ ，根据 $i=2$ 的推论，插入 $a_7$。。。。。。吗？

要注意了！！！由于区间长度 $k=3$ ，此时队首元素 $a_4=-3$ 已经超出了区间长度的限制，无论有多小都不能对答案做出贡献，所以必须从队首弹出队列！

所以弹出 $a_4$ ，插入 $a_7$ 。

队列：5 6 7，最小值为 5。

最后 $i=8$ 时，首先弹出 $a_4$ （过时了），然后？？？ $a_8=a_7=7$ ，那么需不需要更新呢？

需要！考虑到有区间长度的限制，所以 $a_8$ 必然比 $a_7$ 更优，因此需要从队尾弹出 $a_7$ ，插入 $a_8$ 。

队列：6 7，最小值为 6，不过此时的 7 代表 $a_8$ 。

那么这样一来就有一个维护问题了，如何知道这个 7 代表 $a_7$ 还是 $a_8$ 呢？

实际写代码时为了避免这个情况，我个人通常会使用数组下标存到队列里面，这样就没有这个问题了，后面的代码都是如此。

理解如何使用单调队列求区间最小值后，求区间最大值就很轻松了，只需要仿照上述步骤，在队列内维护一个单调下降序列即可。

模板的代码：

#include
using namespace std;

const int MAXN=1e6+10;
int n,k,a[MAXN],ans[MAXN][2];
deque<int>q;

int read()
{
	int fh=1,sum=0;
	char ch=getchar();
	while(ch<'0'||ch>'9')
	{
		if(ch=='-') fh=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9')
	{
		sum=(sum<<3)+(sum<<1)+ch-'0';
		ch=getchar();
	}
	return sum*fh;
}

void GetMin()
{
	deque<int>q;
	for(int i=1;i<=n;i++)
	{
		while(!q.empty()&&i-q.front()>=k) q.pop_front();
		while(!q.empty()&&a[i]<=a[q.back()]) q.pop_back();
		q.push_back(i);
		if(i-k+1>0) ans[i-k+1][0]=a[q.front()];
	}
}

void GetMax()
{
	deque<int>q;
	for(int i=1;i<=n;i++)
	{
		while(!q.empty()&&i-q.front()>=k) q.pop_front();
		while(!q.empty()&&a[i]>=a[q.back()]) q.pop_back();
		q.push_back(i);
		if(i-k+1>0) ans[i-k+1][1]=a[q.front()];
	}
}

int main()
{
	n=read();k=read();
	for(int i=1;i<=n;i++) a[i]=read();
	GetMin();
	GetMax();
	for(int i=1;i<=n-k+1;i++) cout<<ans[i][0]<<" ";
	cout<<"\n";
	for(int i=1;i<=n-k+1;i++) cout<<ans[i][1]<<" ";
	return 0;
}

如果你成功理解了上述代码，那么恭喜你，学会了单调队列！

接下来是几道例题。

3.例题

例题1：luogu P1714

暴力方法显而易见，那么我们如何使用单调队列解决此题呢？

推敲题意可以发现：假如我们取出一个 $n\ast n$ 的矩阵 $a$ ，那么这个矩阵的最大值一定是每一列最大值的最大值，最小值一定是每一列的最小值的最小值。

这就好做了！对每一列跑一次区间长度为 $n$ 的单调队列，设 $f[i][j][0/1]$ 表示第 $j$ 列从第 $i-k+1$（如果小于 1 则从 1 开始） 行开始到第 $i$ 行止的最大值/最小值，跑单调队列时存储答案，然后从第 $n$ 行开始对每一行跑一次关于 $f$ 的单调队列，计算最大值与最小值即可。更新答案时需要注意，只有 $n\le j$ 时才需要更新答案。

代码：

#include
using namespace std;

const int MAXN=1000+10;
int n,m,k,a[MAXN][MAXN],f[MAXN][MAXN][2],ans=0x7f7f7f7f;

int read()
{
	int fh=1,sum=0;
	char ch=getchar();
	while(ch<'0'||ch>'9')
	{
		if(ch=='-') fh=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9')
	{
		sum=(sum<<3)+(sum<<1)+ch-'0';
		ch=getchar();
	}
	return sum*fh;
}

void lie()
{
	for(int j=1;j<=m;j++)
	{
		deque<int>qmax,qmin;
		for(int i=1;i<=n;i++)
		{
			while(!qmax.empty()&&i-qmax.front()>=k) qmax.pop_front();
			while(!qmin.empty()&&i-qmin.front()>=k) qmin.pop_front();
			while(!qmax.empty()&&a[i][j]>=a[qmax.back()][j]) qmax.pop_back();
			while(!qmin.empty()&&a[i][j]<=a[qmin.back()][j]) qmin.pop_back();
			qmax.push_back(i),qmin.push_back(i);
			f[i][j][0]=a[qmax.front()][j];
			f[i][j][1]=a[qmin.front()][j];
		}
	}
}//对每一列跑一次单调队列

void hang()
{
	for(int i=k;i<=n;i++)
	{
		deque<int>qmax,qmin;
		for(int j=1;j<=m;j++)
		{
			while(!qmax.empty()&&j-qmax.front()>=k) qmax.pop_front();
			while(!qmin.empty()&&j-qmin.front()>=k) qmin.pop_front();
			while(!qmax.empty()&&f[i][j][0]>=f[i][qmax.back()][0]) qmax.pop_back();
			while(!qmin.empty()&&f[i][j][1]<=f[i][qmin.back()][1]) qmin.pop_back();
			qmax.push_back(j),qmin.push_back(j);
			if(j>=k) ans=min(ans,f[i][qmax.front()][0]-f[i][qmin.front()][1]);
		}
	}
}//对每一行跑一次单调队列

int main()
{
	n=read();m=read();k=read();
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			a[i][j]=read();
	lie();
	hang();
	cout<<ans<<"\n";
	return 0;
}

例题2:luogu P2698

详见这篇博客

例题3:烽火传递(Noip 2010 tg 初赛 完善程序 T2)

题目大意：给定数列 $a_{1...n}$，从中选出若干个数使得连续 $m$ 个数内至少有一个数被选中，求被选中的数和的最小值。

输入格式：

第一行 $n,m$ ，第 2 行 $n$ 个数表示 $a_{1...n}$。

范围：$1\le m\le n\le 10^5,1\le a_i\le 100$。

输出格式：

求被选中的数和的最小值。

样例：

input:
5 3
1 2 5 6 2
output:
4

题解：

其实我并不是太懂出题人给的程序。。。所以怎么用单调队列呢？

这一道题有最小二字，结合数据范围，可以推断出这道题是一道 dp 题。（说贪心的请自行靠边站）

首先设状态：设 $f_i$ 表示取第 $i$ 个数后前 $i$ 个数取数的最小值。

然后推方程：$f_i=\min (f_j)+a_i,j\in [i-m,i-1]$ ，应该不难想吧。

所以如何使用单调队列呢？观察到 $\min (f_j),j\in [i-m,i-1]$，显然是固定长度 $m$ ，可以使用单调队列维护。

这是一道经典的单调队列优化 dp 的题目，放代码：

#include
using namespace std;

const int MAXN=1e5+10;
int n,m,f[MAXN],a[MAXN],ans;
deque<int>q;

int read()
{
	int fh=1,sum=0;
	char ch=getchar();
	while(ch<'0'||ch>'9')
	{
		if(ch=='-') fh=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9')
	{
		sum=(sum<<3)+(sum<<1)+ch-'0';
		ch=getchar();
	}
	return sum*fh;
}

int main()
{
	n=read();m=read();ans=0x7f7f7f7f;
	for(int i=1;i<=n;i++) a[i]=read();
	q.push_back(0);//记得把0推入队列，原因请自行思考
	for(int i=1;i<=n;i++)
	{
		while(!q.empty()&&i-q.front()>m) q.pop_front();
		f[i]=f[q.front()]+a[i];
		while(!q.empty()&&f[q.back()]>=f[i]) q.pop_back();
		q.push_back(i);
	}
	for(int i=n;i>=n-m+1;i--) ans=min(ans,f[i]);
	cout<<ans<<"\n";
	return 0;
}

例题4:CF372C

详见这篇博客

4.总结

相信在做完上述题目后，各位对单调队列有了一定程度的了解。单调队列可以用来维护一个序列上固定长度区间的最大最小值，可以与各种算法如 dp 相结合。