单调队列洛谷p1886 【单调队列】滑动窗口 nkojp2152

Jinxin23

已于 2023-11-25 17:40:15 修改

阅读量328

点赞数 5

文章标签：算法 c++ 数据结构推荐算法

于 2023-11-24 21:31:48 首次发布

本文链接：https://blog.csdn.net/weixin_44281309/article/details/134606620

版权

文章介绍了如何使用单调队列解决窗口滑动中寻找每次滑动后窗口内最大值和最小值的问题，原始暴力解法时间复杂度为O(n^2)，通过快读和单调队列优化后降低时间复杂度，但仍有提升空间，鼓励读者分享更高效的解决方案。

摘要由CSDN通过智能技术生成

最近老师讲了单调队列，正好发现一道模板题，特来练手。

本题链接

题目描述

有一个长为 n 的序列 a，以及一个大小为 k 的窗口。现在这个从左边开始向右滑动，每次滑动一个单位，求出每次滑动后窗口中的最大值和最小值。

暴力尝试

根据题意可得，肯定想到的方法是暴力便利，每次都重新记录下最小值与最大值，别忘了清0！

代码如下：

#include<bits/stdc++.h>
using namespace std;
long long a,b,Min=0x3f3f3f3f,Max=-0x3f3f3f3f;//不开long long见祖宗
int c[1000005],d[1000005],e[1000005],f[1000005],g[1000005];
int main(){
    cin>>a>>b;
    for(int i=1;i<=a;i++){
        cin>>c[i];
    }
    for(int i=1;i<=a-b+1;i++){
        for(int j=i;j<i+b;j++){
            if(c[j]<Min){
                Min=c[j];
            }
            if(c[j]>Max){
                Max=c[j];
            }
        }
        f[i]=Min;
        g[i]=Max;
        Min=0x3f3f3f3f;
        Max=-0x3f3f3f3f;
    }
    for(int i=1;i<=a-b+1;i++){
        cout<<f[i]<<" ";
    }
    cout<<endl;
    for(int i=1;i<=a-b+1;i++){
        cout<<g[i]<<" ";
    }
    return 0;
}

这是样例情况。

本代码时间复杂度约是o(n的平方)，但说不定开快读能卡过。（快读能够优化输入与输出）

快读代码

ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);

再来运行一遍。

虽然有优化，但还是TLE了。

但有的人偏要钻牛角尖，来个超级快读，代码就成了这样：

#include<bits/stdc++.h>
#pragma GCC target("avx")
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
using namespace std;
long long a,b,Min=0x3f3f3f3f,Max=-0x3f3f3f3f;//不开long long见祖宗
int c[1000005],d[1000005],e[1000005],f[1000005],g[1000005];
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
    cin>>a>>b;
    for(int i=1;i<=a;i++){
        cin>>c[i];
    }
    for(int i=1;i<=a-b+1;i++){
        for(int j=i;j<i+b;j++){
            if(c[j]<Min){
                Min=c[j];
            }
            if(c[j]>Max){
                Max=c[j];
            }
        }
        f[i]=Min;
        g[i]=Max;
        Min=0x3f3f3f3f;
        Max=-0x3f3f3f3f;
    }
    for(int i=1;i<=a-b+1;i++){
        cout<<f[i]<<" ";
    }
    cout<<endl;
    for(int i=1;i<=a-b+1;i++){
        cout<<g[i]<<" ";
    }
    return 0;
}

洛谷上交不行，但其他的应该可以，但也不一定能过。

如何才能即便捷，迅速又能正确？

单调队列

那就要换一种算法——单调队列。

首先单调队列遇到这题要考虑最重要的两点，好久被踢出，队列是否保持单调性。

然后判断队列是否为空：

！q.empty()

再是队列是否单调：

c[q.back()]>c[i]

底下就是核心代码：

			while(!q.empty()&&c[q.back()]>c[i]){
				q.pop_back();
			}
			q.push_back(i);
			if(!q.empty()&&q.front()<(i-b+1)){
				q.pop_front();
			}

去头去尾——随后查询。

掌握了关键部分，代码就可以写出来啦。

#include<bits/stdc++.h>
using namespace std;
long long a,b,c[2000005];
deque<int >q,p;
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin>>a>>b;
	for(int i=1;i<=a;i++){
		cin>>c[i];
		while(!q.empty()&&c[q.back()]>c[i]){
			q.pop_back();
		}
		q.push_back(i);
		if(!q.empty()&&q.front()<(i-b+1)){
			q.pop_front();
		}
		if(i>=b){
			cout<<c[q.front()]<<" ";	
		}
	}
	cout<<endl;
	for(int i=1;i<=a;i++){
		while(!p.empty()&&c[p.back()]<c[i]){
			p.pop_back();
		}
		p.push_back(i);
		if(!p.empty()&&p.front()<(i-b+1)){
			p.pop_front();
		}
		if(i>=b){
			cout<<c[p.front()]<<" ";
		}
		
	}
	return 0;
}

然后是运行时间：