第二章 数据结构 单调栈和单调队列

1、算法思路

这两个算法的核心思想是：
只有那些符合某种单调性的元素才有可能是答案。根据题目要求筛掉那些不符合单调性的元素，在栈中或者队列中存储那些符合某种单调性的元素，并根据题目获得这些元素中的极大值、极小值（位置通常在栈顶、队头、队尾），或者依据单调性，通过二分得到某些元素的值。
这样说起来比较抽象，我们下面分别找两个例题进行分析。
这两种算法所能处理的题目种类有限，多多积累即可。

2、例题分析

1、单调栈

原题连接：单调栈

给定一个长度为 N 的整数数列，输出每个数左边第一个比它小的数，如果不存在则输出 −1。

输入格式
第一行包含整数 N，表示数列长度。

第二行包含 N 个整数，表示整数数列。

输出格式
共一行，包含 N 个整数，其中第 i 个数表示第 i 个数的左边第一个比它小的数，如果不存在则输出 −1。

数据范围
1≤N≤10^5
1≤数列中元素≤10^9
输入样例：
5
3 4 2 7 5
输出样例：
-1 3 -1 2 2

1.思路分析

此题也可以改成寻找右边第一个比这个数大的（小的）第一个数。

• 先思考暴力做法
  暴力做法就是,使用两重循环，对于每一个数，再从头去寻找每个数左边第一个比它小的数字。
• 再观察什么样的元素永远不可能成为答案
  我们考虑样例中的4和2,对于2之后的元素来说，如果4比该元素小，那么2一定比该元素小，而2又比4更靠近该元素，所以对于2之后的元素，4永远不会成为答案。拓展到一般情况，如果x、y是逆序的（也就是如果x<y，并且x比y更靠右），那么对于x右边的元素来说，不可能选择元素y。所以对于x右边的元素来说，可能会选择的元素一定是单调递增排列的（因为但凡逆序的都不可能被选择)。我们用栈来存储这些可能会被选择的元素，越靠近栈顶越大，并且越靠右。

2. 代码实现

#include<cstdio>
using namespace std;
const int N = 1e5 + 10;
int stk[N],tt;
int main()
{
	int n;
	scanf("%d",&n);
	for(int i = 0; i < n; i ++)
	{
		int tmp;
		scanf("%d",&tmp);
		//将所有大于tmp的不可能成为答案的数字出栈
		while(tt && stk[tt] >= tmp)
		{
			tt --;
		}
		if(tt == 0)
		{
			printf("-1 ");
		}else{
			printf("%d ",stk[tt]);
		}
		stk[++ tt] = tmp;
	}
}

3.时间复杂度分析

虽然看起来是两重循环，但是对于里面的while来说，总共最多执行n次，所以算法时间复杂度为$O(n)$

2、单调队列

原题连接：滑动窗口

给定一个大小为 n≤10^6 的数组。
有一个大小为 k 的滑动窗口，它从数组的最左边移动到最右边。
你只能在窗口中看到 k 个数字。
每次滑动窗口向右移动一个位置。

以下是一个例子：
该数组为 [1 3 -1 -3 5 3 6 7]，k 为 3。

窗口位置					最小值        	最大值
[1 3 -1] -3 5 3 6 7	     -1				  3
1 [3 -1 -3] 5 3 6 7	     -3				  3
1 3 [-1 -3 5] 3 6 7	     -3				  5
1 3 -1 [-3 5 3] 6 7	     -3				  5
1 3 -1 -3 [5 3 6] 7	      3				  6
1 3 -1 -3 5 [3 6 7]	      3				  7
你的任务是确定滑动窗口位于每个位置时，窗口中的最大值和最小值。

输入格式
输入包含两行。
第一行包含两个整数 n 和 k，分别代表数组长度和滑动窗口的长度。
第二行有 n 个整数，代表数组的具体数值。
同行数据之间用空格隔开。

输出格式
输出包含两个。

第一行输出，从左至右，每个位置滑动窗口中的最小值。
第二行输出，从左至右，每个位置滑动窗口中的最大值。

输入样例：
8 3
1 3 -1 -3 5 3 6 7
输出样例：
-1 -3 -3 -3 3 3
3 3 5 5 6 7

1.思路分析

• 先考虑暴力做法，每选定一个区间，遍历一遍这个区间的所有元素挑出最大值和最小值。
• 再观察什么样的元素不会被选定为答案
  假设我们求最小值，k = 3，我们考虑样例中区间[-1 -3 5]来说，当-3出现的时候，他前面的-1永远不可能称为一个区间的结果了。因为-1不仅比-3大，而且-3还比-1来得晚，离开区间的晚，也就是-1会在-3离开区间之前离开区间，又因为-1大于-3，所以此时-1不可能再成为结果。所以对于每一个新进入区间的元素来说，此时区间中所有大于它的元素都不会再成为答案了，也就是所有可能成为答案的都是小于它的数。所以我们用一个队列来维护该区间中所有可能成为答案的数字，每插入一个数字，比它大的数字就会被驱逐出队列，队列中始终维护的是一个从小到大排列的单调队列。

2.代码实现

#include<iostream>
using namespace std;
const int N = 1e6 + 10;
//q中存储的元素在s中的位置，虽然q中元素不是单调的，但是他们表示的元素是单调的
//h表示头指针，t表示尾指针，s用来存储数据
int q[N],s[N],h,t;

int main()
{
    int n,k;
    cin >> n >> k;
    for(int i = 0; i < n; i ++)
    {
        cin >> s[i];
    }
    //找最小值
    for(int i = 0; i < n; i ++)
    {
    	//判断队头是否应该出队
        if(h != t && i - k + 1 > q[h]) h ++;
        //将大于s[i]的这些不可能成为答案的数出队
        while(h != t && s[q[t - 1]] > s[i]) t --;
        q[t ++] = i;
        if(i >= k - 1)
        cout << s[q[h]] << " ";
    }
    cout << endl;
    //找最大值
    h = 0,t = 0;
    for(int i = 0; i < n; i ++)
    {
        if(h != t && i - k + 1 > q[h])h ++;
        //将小于s[i]的这些不可能成为答案的数出队
        while(h != t && s[q[t - 1]] < s[i]) t --;
        q[t ++] = i;
        if(i >= k - 1)
        cout << s[q[h]] << " ";
    }
}

3.时间复杂度分析

while中每个元素只会入队出队一次，所以总共进行2n次操作，时间复杂度为$O(n)$

参考资料

Acwing