单调栈 + 单调队列

---

单调栈

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

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

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

数据范围
1≤N≤105
1≤数列中元素≤109

输入样例：

5
3 4 2 7 5

输出样例：

-1 3 -1 2 2

---

朴素做法是先遍历每一个数，然后每轮从第i个数开始，逆序往前找到第一个比该数小的数，便是答案，这么做的复杂度为 O(n^2)。

利用单调栈来优化的核心思路是对于第i个数，如果前一个数(i-1)比第i个数大，那么可以判断出它永远不会作为后面某个数的答案，因为对于i后面那一堆数而言，第i个数比起第i - 1个数具有更小，更近的特点，因此可以将第i - 1个数从候选答案中排除掉；

而当前一个数(i-1)比第i个数小时不能将其排除掉，所以第i - 1、i个数放在一起作为候选答案(入栈)；

将这些所谓的候选答案存到栈里面，不难发现利用上述的排除元素的规则，栈里边的元素都是单调递增的，所以称之为“单调栈”。

1. 如果栈顶元素比第i个数小，则栈顶就是距离i最近、较小的数，将其输出，否则被排除，将其弹出。
2. 如果第i个数经若干次排除掉栈里边的元素(出栈)操作后 栈空，说明第i个数前没有候选答案，也即不存在比它小的数了，所以输出-1。

无论怎样，第i个数都会入栈，因为它具有成为后面一堆数的候选答案可能性。

最终，整个算法的复杂度直接降到了 O(n)。

下面可以一图看懂单调栈元素入栈、出栈过程变化，图片来源于海绵宝宝。

---

C++代码

#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <stack>
using namespace std;

int N, num;
stack<int> stk;

int main(){
    cin >> N;
    
    while (N --){
        cin >> num;
        while(!stk.empty() && stk.top() >= num)     //排除掉不会再作为候选答案的数
            stk.pop();
        if(stk.empty())
            cout << "-1" << " ";
        else
            cout << stk.top() << " ";
        stk.push(num);
    }
    
    return 0;
}

---

单调队列

滑动窗口
给定一个大小为 n≤106 的数组。

有一个大小为 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

---

朴素做法的思路仍是外层循环遍历每个区间，内层循环找最值，复杂度是 O(n^2)。

利用单调队列优化的思路跟单调栈如出一辙，也是利用排除候选答案的方法。

但这里的队列是一个双向队列，特点是可以在队头、队尾都进行入队、出队操作，其存储的是各元素的下标。

其思想是遍历到第i个数时，如果前一个数(i - 1)比第i个数大，那么可以将其i - 1从候选答案下标中排除(队尾出队)，因为第i - 1要么不在此时的窗口里，那作为最值更不可能，要么和i处在同一窗口，但不是最小值，所以这种做法合理。最后将第i个数入队。

可以发现始终保持队列的下标对应值是单调递增的，说明队头front是[front, i]这个区间里最小的值，进一步，如果[front, i]处在滑动窗口的区间里，那队头就是此刻滑动窗口状态下的最小值。

要注意的是，滑动窗口的区间是[i - k, i]，每次都需要判断队头是否还处在窗口里(≤ i - k)，如果不在需要就将其出队，这样保证了队列里的元素都是处在了窗口里的有效元素。

上述做法是维护了一个单调递增的队列，寻找到滑动窗口的最小值，而寻找滑动窗口的最大值的方法同理，只需在第i个数和队尾比较时修改一下条件。

---

下面这个链接有一个很好的过程演示：

LeetCode 239. 滑动窗口最大值

---

C++代码

#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <deque>
using namespace std;

int a[1000010];
int n, k;
deque<int> q;       //存还未被排除元素下标

int main(){
    cin >> n >> k;
    q.clear();
    for(int i = 0;i < n;i ++)       scanf("%d", &a[i]);

    //getMin：保持队列单调递增
    for(int i = 0;i < n;i ++){
        while(!q.empty() && a[q.back()] > a[i])     //维护单调
            q.pop_back();
        q.push_back(i);         //当前数的下标入队

        if(i >= k - 1){       //形成滑动窗口的条件
            if(q.front() <= i - k)
                q.pop_front();      //队头不在滑动窗口内，弹出
            cout << a[q.front()] << " ";
        }
    }
    printf("\n");
    q.clear();
    //getMax：保持队列单调递减，同理
    for(int i = 0;i < n;i ++){
        while(!q.empty() && a[q.back()] < a[i])
            q.pop_back();
        q.push_back(i);

        if(i >= k - 1){
            if(q.front() <= i - k)
                q.pop_front();
            cout << a[q.front()] << " ";
        }
    }

    return 0;
}