单调队列 (Sliding Window)

单调队列

单调对列是单调递减或单调递增的队列。也就是在队列性质的基础上，维护一个单调的序列。

模板：

常见模型：找出滑动窗口中的最大值/最小值
int hh = 0, tt = -1;
for (int i = 0; i < n; i ++ )
{
    while (hh <= tt && check_out(q[hh])) hh ++ ;  // 判断队头是否滑出窗口
    while (hh <= tt && check(q[tt], i)) tt -- ;
    q[ ++ tt] = i;
}

例题：

acwing 154. 滑动窗口

给定一个大小为 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. 要保证滑动窗口的完整
2. 要保证队列的单调性。
3. 队列是个双端队列，不止队头可以出队，队尾也可以出队。

刚开始遍历时，hh = 0, tt = -1，要有一个形成窗口的过程，此过程没有最大值，hh 不动，tt 向右移。当窗口大小形成时，hh 和 tt 一起向右移，每次移动时，判断队首的值的数组下标是否在 [hh,tt] 中，如果不在则需要弹出队首的值，当前窗口的最大值即为队首的数。

#include <iostream>
using namespace std;

const int N = 1000010;
int a[N], q[N];

int main()
{
    int n, k;
    scanf("%d%d", &n, &k);
   
    // hh是队头指针，tt是队尾指针
    int hh = 0, tt = -1;
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
        if (hh <= tt && i - k + 1 > q[hh]) hh++;
        while (hh <= tt && a[i] <= a[q[tt]]) tt--; // 如果出现比队尾元素还要小的元素，就从队尾将不符合条件的元素全部出队
        q[++tt] = i; // 
        // 判断窗口是否形成，因为一开始没有形成窗口
        if (i >= k - 1)
            printf("%d ", a[q[hh]]); // 此时队头元素时队列中的最小值也是滑动窗口中的最小值，输出队头元素就是答案
    }
    puts("");
    // 与上面找出最小值类似，只需要改变条件将队列变为单调递减的队列 
    hh = 0, tt = -1;
    for (int i = 0; i < n; i++) {
        if (hh <= tt && i - k + 1 > q[hh]) hh++;
        while (hh <= tt && a[i] >= a[q[tt]]) tt--;
        q[++tt] = i;
        if (i >= k - 1)
            printf("%d ", a[q[hh]]);
    }
    return 0;    
}

上题与leetcode 239. 滑动窗口最大值相似

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

题解：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int n = nums.length;
        if (n == 1) {
            return new int[]{nums[0]};
        }
        int[] res = new int[n - k + 1];
        int[] q = new int[n];
        int hh = 0, tt = -1;
        int idx = 0;

        for (int i = 0; i < n; i ++) {
            if (hh <= tt && i - k + 1 > q[hh]) hh++;
            while (hh <= tt && nums[i] >= nums[q[tt]]) tt--;
            q[++tt] = i;
            if (i >= k - 1) 
                res[idx++] = nums[q[hh]];
        }
        return res;
    }
}