单调队列 POJ 2823 Sliding Window

最新推荐文章于 2020-10-07 20:49:17 发布

原创最新推荐文章于 2020-10-07 20:49:17 发布 · 181 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

栈和队列专栏收录该内容

6 篇文章

订阅专栏

本文介绍了一种使用单调队列解决滑动窗口中最大值和最小值问题的算法，通过构造单调增减队列，高效地计算出每个滑动窗口的最大值和最小值，适用于大规模数据处理。

Sliding Window

An array of size n ≤ 10 6 is given to you. There is a sliding window of size kwhich is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves rightwards by one position. Following is an example:
The array is [1 3 -1 -3 5 3 6 7], and k is 3.

Window position	Minimum value	Maximum value
[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

Your task is to determine the maximum and minimum values in the sliding window at each position.

Input

The input consists of two lines. The first line contains two integers n and k which are the lengths of the array and the sliding window. There are n integers in the second line.

Output

There are two lines in the output. The first line gives the minimum values in the window at each position, from left to right, respectively. The second line gives the maximum values.

Sample Input

8 3
1 3 -1 -3 5 3 6 7

Sample Output

-1 -3 -3 -3 3 3
3 3 5 5 6 7

题意：求区间宽为M，从左到右平移，求每个区间的最大值，最小值。

解法单调队列：

单调队列顾名思义维护一个单调减或单调增的队列，为了得到这个区间的最大值最小值，我们只需要和队头去比较就行了。

要的得到最小值，就要维护单调增的，因为这样队头才最小。

然后这个题还要注意，每个元素必须要在那一时刻的区间类，队列的每个元素的小下标必须维护大于区间前端。

接下来数组模拟就行啦……

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <cmath>
using namespace std;
typedef long long ll;
const int INF=0x3f3f3f3f;
const int maxn=1e6+7;
int n,m;
struct node
{
    int id;
    int val;
}q[maxn];
int ansmin[maxn];
int ansmax[maxn];
int a[maxn];
int head,tail;
void getmin()
{
    ///构造一个单调增的队列保证队头的元素始终是最小的，每次只比较队头
    ///先将前k-1个入队
    int i;
    head=1;
    tail=0;
    for(i=1;i<m;++i)
    {
        while(head<=tail&&q[tail].val>=a[i])/// 队尾元素大于将要入队的元素
            --tail;
        q[++tail].val=a[i];
        q[tail].id=i;
    }
    for(;i<=n;++i)
    {
        while(head<=tail&&q[tail].val>=a[i])/// 队尾元素大于将要入队的元素
            --tail;
        q[++tail].val=a[i];
        q[tail].id=i;
        while(q[head].id<i-m+1)
        {
            ++head;
        }
        ansmin[i-m+1]=q[head].val;
    }
    for(int i=1;i<n-m+1;++i)
        cout<<ansmin[i]<<' ';
    cout<<ansmin[n-m+1]<<endl;
}
void getmax()
{
    int i;
    head=1;
    tail=0;
    ///构造单调减的队列
    for(i=1;i<m;++i)
    {
        while(head<=tail&&q[tail].val<=a[i])
            tail--;
        q[++tail].id=i;
        q[tail].val=a[i];
    }
    for(;i<=n;++i)
    {
        while(head<=tail&&q[tail].val<=a[i])
            tail--;
        q[++tail].id=i;
        q[tail].val=a[i];
        while(q[head].id<i-m+1)
            ++head;
        ansmax[i-m+1]=q[head].val;

    }
    for(int i=1;i<n-m+1;++i)
        cout<<ansmax[i]<<' ';
    cout<<ansmax[n-m+1]<<endl;
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=1;i<=n;++i)
            scanf("%d",&a[i]);
        getmin();
        getmax();


    }
    return 0;
}