【大渣】【单调队列】滑动窗口

最新推荐文章于 2024-10-15 11:15:00 发布

BlackBullet_CN

最新推荐文章于 2024-10-15 11:15:00 发布

阅读量681

点赞数

分类专栏：学习交流题目文章标签： STL 单调队列

本文链接：https://blog.youkuaiyun.com/Musame/article/details/49612651

版权

学习交流同时被 2 个专栏收录

18 篇文章

订阅专栏

题目

6 篇文章

订阅专栏

本文深入探讨了使用单调队列解决滑动窗口问题的算法原理及其实现过程，包括如何求解最大值和最小值。通过具体实例展示了算法应用，并提供了简洁的代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

【单调队列】滑动窗口

Time Limit:10000MS Memory Limit:65536K
Total Submit:195 Accepted:85
Case Time Limit:1000MS

Description

给你一个长度为N(N<=10^6)的数组，一个长为K的滑动的窗体从最左移至最右端，你只能见到窗口的K个数，每次窗体向右移动一位，找出窗体所包含的数字的最大和最小值，如下表所示：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

Input

第1行为n，k，第2行为长度为n的数组。

Output

共2行，第1行是每个位置的min value，第2行是每个位置的max value。

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

Source

poj 2823

===============================================================

裸的单调队列我们就只说求最大值怎么求吧

Step:

1.判断要加入队列的元素是否比队尾元素大，若是删掉队尾元素，直到队列为空或者

比队尾元素小为止。

2.判断队首元素的下标是否在滑动窗口内，若不是，删掉。

3.加入元素。

4.输入队首元素，此时必定为窗口内的最大值

求最小同理，就不写了 0.0

================================================================

放代码：

#include<cstdio>
#include<deque>
#include<iostream>
#include<cstdlib>
#define maxn 1000005
using namespace std;
int n,k,a[maxn];
void _r(int& d)
{
 	char t=getchar();bool f=false;
 	while(t<'0'||t>'9') {if(t=='-') f=true; t=getchar();}
 	for(d=0;t<='9'&&t>='0';t=getchar()) d=d*10+t-'0';
 	if(f) d=-d;
}
void _o(int d)
{
 	int o[30],top=1;
 	if(d==0){putchar('0');return ;}
 	if(d<0) {putchar('-');d=-d;}
 	while(d)
 	{
 		o[top++]=d%10;
 		d/=10;
 	}
 	for(--top;top;--top) putchar('0'+o[top]);
}

void _find_min()
{
    deque<int>Q,Qr;
	int i,j;
	Q.push_front(a[1]);
	Qr.push_front(1);
	for(i=2,j=2;i<=n;i++)
	{
		while(Q.back()>a[j]&&Q.size())
		{
		  Q.pop_back();
		  Qr.pop_back();
	    }
	    while(Qr.front()<(i-k+1)&&Qr.size())
	    {
	    	Q.pop_front();
	    	Qr.pop_front();
	    }
	    Q.push_back(a[j]);
	    Qr.push_back(j);
	    j++;
	    if(i>=k)
		{
			_o(Q.front());
			putchar(32);
		}
		
	}
}
void _find_max()
{
	deque<int>Q,Qr;
	int i,j;
	Q.push_front(a[1]);
	Qr.push_front(1);
	for(i=2,j=2;i<=n;i++)
	{
		while(Q.back()<a[j]&&Q.size())//step.1
		{
		  Q.pop_back();
		  Qr.pop_back();
	    }
	    while(Qr.front()<(i-k+1)&&Qr.size())//step.2
	    {
	    	Q.pop_front();
	    	Qr.pop_front();
	    }
	    Q.push_back(a[j]);//step.3
	    Qr.push_back(j);
	    j++;
	    if(i>=k)//step.4
		{
			_o(Q.front());
			putchar(32);
		}
		
	}
}
int main()
{
	int i,j;
	_r(n),_r(k);
	for(i=1;i<=n;i++)_r(a[i]);
	_find_min();
	putchar(10);
	_find_max();
	return 0;
}