单调队列算法 - 滑动窗口问题（常见模型：找出滑动窗口中的最大值/最小值）

欢迎观看我的博客，如有问题交流，欢迎评论区留言，一定尽快回复！（大家可以去看我的专栏，是所有文章的目录）
文章字体风格：
红色文字表示：重难点✔
蓝色文字表示：思路以及想法✔
　
如果大家觉得有帮助的话，感谢大家帮忙
点赞！收藏！转发！

1. 单调队列模板

常见模型：找出滑动窗口中的最大值/最小值
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;
}

例题 - 滑动窗口

首先，看完这个题，我自己的一个想法是

1. 最大值和最小值分两次求
2. 先找到前k个中最小的一个，然后在k+1开始遍历
3. 如果前k个中最小的是窗口中滑出的那一个，则在min+1到i，重新找到一个新的最小值，然后再次比较
4. 如果不是的话。。。。具体逻辑代码就体现出来了

#include<iostream>
using namespace std;

const int N = 1e6+10;
int q[N],tt,hh = 1;
int a[N];

int main()
{
    int n,k;
    cin >> n >> k;
    int min = 1;
    for(int i = 1; i <= n; i++)
        cin >> a[i];
    
    for(int i = 1; i <= k; i++)
    {
        if(a[min] > a[i])
            min = i;
    }
    q[hh++] = a[min];
    printf("%d ",q[hh-1]);
    for(int i = k+1; i <= n; i++)
    {
        if(min+k<=i)
        {
            int kk = min+1;
            min+=1;
            while(kk <= i)
            {
                 if(a[min] > a[kk])
                 {
                     min = kk;
                 }
                 kk++;
            }
            q[hh++] = a[min];
            printf("%d ",q[hh-1]);
        }
        else if(a[i] <= a[min])
        {
            q[hh++] = a[i];
            min = i;
            printf("%d ",q[hh-1]);
        }
        else
        {
            q[hh++] = a[min];
            printf("%d ",q[hh-1]);
        }
    }
    
    cout << endl;
    hh = 1,tt = 0;
    min = 1;
    for(int i = 1; i <= n; i++)
        cin >> a[i];
    
    for(int i = 1; i <= k; i++)
    {
        if(a[min] < a[i])
            min = i;
    }
    q[hh++] = a[min];
    printf("%d ",q[hh-1]);
    for(int i = k+1; i <= n; i++)
    {
        if(min+k<=i)
        {
            int kk = min+1;
            min+=1;
            while(kk <= i)
            {
                 if(a[min] < a[kk])
                 {
                     min = kk;
                 }
                 kk++;
            }
            q[hh++] = a[min];
            printf("%d ",q[hh-1]);
        }
        else if(a[i] >= a[min])
        {
            q[hh++] = a[i];
            min = i;
            printf("%d ",q[hh-1]);
        }
        else
        {
            q[hh++] = a[min];
            printf("%d ",q[hh-1]);
        }
    }
    
    return 0;
}

代码关键

这个代码 超时了
问题就出现在了第3条中
当最小值滑出窗口，我们不应该重新遍历找最小值，如果可以直接找到最小值，或者说减少寻找次数最好

所以我们就采取了另一种方式
创建一个具有单调性的队列，
每次判断的时候，如果i对应的值，满足队列的单调性就入队列
如果不满足，那么就从队尾往前更改队列，使得队列具有单调性，且还具有一定的顺序性，

有个关键问题：单调队列存储的是 数值还是数值的角标？
如果存储的是数值的话，但最值滑出窗口，我们更新最值，但是我们就不能有效得到最值的角标进而去判断下一个最值什么时候滑出窗口。
所以我们应该存储的是角标

#include <iostream>

using namespace std;

const int N = 1000010;

int a[N], q[N];

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

    int hh = 0, tt = -1;
    for (int i = 0; i < n; i ++ )
    {
        if (hh <= tt && i - k + 1 > q[hh]) hh ++ ;

        while (hh <= tt && a[q[tt]] >= a[i]) 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[q[tt]] <= a[i]) tt -- ;
        q[ ++ tt] = i;

        if (i >= k - 1) printf("%d ", a[q[hh]]);
    }

    puts("");

    return 0;
}