单调队列专题总结

最新推荐文章于 2023-01-27 21:07:19 发布
最新推荐文章于 2023-01-27 21:07:19 发布
阅读量274 收藏 1
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41661919/article/details/89046442
版权

1、HDU - 4193

题意：

          n个数组成的序列环，求长度小于等于m的字串的最大区间和。

思路：

          如果n个数为线性关系，可以用单调队列维护第i个数之前的m个数，

及时剔除没用的数。o（N）解决。

这里是环，2倍数组破环成链即可。(代码非自己写)

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define maxn 1000005
int n,m,head,rear,ans;
int a[maxn*2],q[maxn*2];
void in_queue(int x)
{
	while(head<=rear && a[x]<=a[q[rear]])//删除队中大于等于它的元素
		rear--;
	q[++rear]=x;//满足条件则下标入队
}
void out_queue(int x)
{
	if(q[head]<x-n+1)
		head++;
}
int  main()
{
	int i;
	while(scanf("%d",&n),n!=0)
	{
		head=ans=0;
		rear=-1;
		for(i=1;i<=n;i++)
		{
			scanf("%d",&a[i]);
			a[n+i]=a[i];
		}
		for(i=2;i<2*n;i++)
			a[i]+=a[i-1];
		for(i=1;i<n;i++)
			in_queue(i);
		for(i=n;i<2*n;i++) //依次求区间[i-n+1,i]中的最小值 
		{
			in_queue(i);
			out_queue(i);
			if(a[q[head]]-a[i-n]>=0)//如果最小值都大于0，计数
				ans++;
		}
		printf("%d\n",ans);
	}
}

2、HDU - 3474

题意：

        由字母C和J组成的序列环，可以从任意一个地方断开，

要求断开后向右或者向左便利序列的过程中保持Number C>=J，

求满足要求的切割方案数。

思路：

暴力：破环成链，枚举终点（或者中点起点都可以），看终点往前的n个数是否满足要求。O（N*N）；

思考：

      n个数满足要求即n个数所有以第一个数为起点的字串和均>=0，或者说其中

最小前缀和-第一个数-1的前缀和>=0，所以问题变为求以第i个数为起点，长度最

长为n的的字串中最小 的前缀和。

     也可以转换为求以第i个数为末尾，长度不超过n的字串中最小的前缀和。只要

起点到该点的序列和>=0 ,则段序列对应的切割点为可行方案。（PS：最开使看的

模板题也是求以第i个数为终点，长度不超过m的字串中最小的/最大的前缀和，（

用单调队列来维护一个长度小于m的序列，该序列只在队头和队尾修改）所以这

题其实是模板的一个变式，如果直接从原理上思考的话不太好考虑）。

#include<bits/stdc++.h>
#define ll long long
#define inf 0x3f3f3f3f
using namespace std;
const int maxn=2e6+50;
int n,m,k;
int tail,head;
int stk[maxn];
int ans;
int a[maxn];
int c[maxn];
char s[maxn];
bool jd[maxn];
int main()
{
    int T,cas=1;
    scanf("%d",&T);
    getchar();
    while(T--)
    {
        memset(jd,0,sizeof(jd));
        scanf("%s",s+1);
        n=strlen(s+1);
        for(int i=1;i<=n;i++)
        {
            a[i]=(s[i]=='C')?1:-1;
            a[n+i]=a[i];
        }
        c[0]=0;
        for(int i=1;i<=2*n;i++)
        {
            c[i]=c[i-1]+a[i];
        }
        ans=0;
        head=-1;tail=0;
        for(int i=1;i<2*n;i++)
        {
            while(head>=tail&&c[i]<c[stk[head]]) head--;
            stk[++head]=i;
            while(head>tail&&i-stk[tail]>=n) tail++;
            if(i>=n&&c[stk[tail]]-c[i-n]>=0) jd[i-n+1]=1;
        }
        c[0]=0;
        for(int i=1;i<=2*n;i++)
        {
            int k=n+n-i+1;
            c[i]=c[i-1]+a[k];
        }
        head=-1;tail=0;
        for(int i=1;i<=2*n;i++)// i<=2*n
        {
            while(head>=tail&&c[i]<c[stk[head]]) head--;
            stk[++head]=i;
            while(head>tail&&i-stk[tail]>=n) tail++;
            if(i>n&&c[stk[tail]]-c[i-n]>=0) jd[n-(i-n)+1]=1;//i>n 注意正反切割地点的下标要一致
        }
        for(int i=1;i<=n;i++)
        if(jd[i]) ans++;
        printf("Case %d: %d\n",cas++,ans);
    }
    return 0;
}

3、HDU - 3530

题意：n个数，求最长 字串 的长度，且该字串满足m<=maxs-mini<=k，，N<=1e5。

思路： 

暴力：枚举所有子串，计算最大值最小值，O（N*N*N）/，虽然线段树不会，不过线段树优化的话也是O（N*N*logN）。

        本质是求子串的最值，所以目前来说有O（N）的单调队列解法。所以考虑开两个队列，

一个递增、一个递减，两者取队头坐标小者作为左边界，i是右边界。当maxs-mini小于m时

进入下一个i，大于k时，调整队列头指针位置，调整谁的呢，就问一句：调整index大的有

用么，调整后原来的对头不照样被区间包含。然后更新ans即可，ans=max（ans，i-L+1+1）

（理想状态下len=不合法的len-1，不行的时候len'不再是len-2，要根据此时的L确定）。

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;

const int MAXN=100010;
int q1[MAXN],q2[MAXN];
int rear1,head1;
int rear2,head2;
int a[MAXN];
int main()
{
  //  freopen("in.txt","r",stdin);
  //  freopen("out.txt","w",stdout);
    int n,m,k;

    while(scanf("%d%d%d",&n,&m,&k)!=EOF)
    {
        rear1=head1=0;
        rear2=head2=0;
        int ans=0;
        int now=1;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            while(head1<rear1&&a[q1[rear1-1]]<a[i])rear1--;//这里的等号取和不取都可以的
            while(head2<rear2&&a[q2[rear2-1]]>a[i])rear2--;
            q1[rear1++]=i;
            q2[rear2++]=i;
            while(head1<rear1&&head2<rear2&&a[q1[head1]]-a[q2[head2]]>k)
            {
                if(q1[head1]<q2[head2])now=q1[head1++]+1;
                else now=q2[head2++]+1;
            }
            if(head1<rear1&&head2<rear2&&a[q1[head1]]-a[q2[head2]]>=m)
            {
                //int t=min(q1[head1],q2[head2]);
                if(ans<i-now+1)ans=i-now+1;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

4、HDU-4122（二维优先队列）

题意：

n分订单，只在m个时刻做蛋糕（第一个时刻：0~1hour）；

n份订单要提交的时刻，每份订单所需要蛋糕的数目；

每个蛋糕自生产时刻起能够保存几个小时，保存一个小时所需要的花费；

m个生产时刻生产蛋糕时生产一个所需要的花费；

N<=2500,M<=1e5,,,

自己的思路：

         O（M）遍历M序列，所需维护的元素最多T个，且维护过程的增删为“窗口滑动”型，

所以队列维族该集合，具体维护以  i 为终点，长度不超过T的字串中花费的最小值，显然

若在一个时刻k后有比其花费小的时刻j，那j之后所有的 时刻中k时刻都不会作为最小花费

被选择，k为无用信息，去掉后即为单调增队列数据结构。（直接单调队列维护）。最后

遍历所有订单提交时刻，统计花费总数。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<map>
#include<iomanip>
#define INF 99999999
using namespace std;
const int MAX=2500+10;
char mon[5];
int M[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
struct Node{
	int num,t;
//对于订单来说num表示月饼数量,t表示订单时间;
//对于制作月饼来说num表示耗费的价值,t表示制作时间 
}order[MAX],q[MAX*4];//q表示单调递增队列
int MON(char *m){
	if(strcmp(m,"Jan") == 0)return 1;
	if(strcmp(m,"Feb") == 0)return 2;
	if(strcmp(m,"Mar") == 0)return 3;
	if(strcmp(m,"Apr") == 0)return 4;
	if(strcmp(m,"May") == 0)return 5;
	if(strcmp(m,"Jun") == 0)return 6;
	if(strcmp(m,"Jul") == 0)return 7;
	if(strcmp(m,"Aug") == 0)return 8;
	if(strcmp(m,"Sep") == 0)return 9;
	if(strcmp(m,"Oct") == 0)return 10;
	if(strcmp(m,"Nov") == 0)return 11;
	return 12;
}
bool LeapYear(int &year){
	return year%4 == 0 && year%100 || year%400 == 0;
}
 int Time(int &year,int Mon,int &d,int &h){
	int t=0;
	for(int i=2000;i<year;++i){
		if(LeapYear(i))t+=366;
		else t+=365;
	}
	bool flag=LeapYear(year);
	for(int i=1;i<Mon;++i){
		if(flag && i == 2)t+=29;
		else t+=M[i];
	}
	t+=d-1;
	return t*24+h;
}
int main(){
	int n,m,t,s,r,h,d,year,a;
	while(~scanf("%d%d",&n,&m),n+m){
		for(int i=0;i<n;++i){
			scanf("%s%d%d%d%d",mon,&d,&year,&h,&r);
			order[i].num=r,order[i].t=Time(year,MON(mon),d,h);
//转化成小时 
		}
		int top=0,tail=0,p=0;
		__int64 sum=0;
		scanf("%d%d",&t,&s);
		for(int i=0;i<m;++i){
			scanf("%d",&a);
			while(top<tail && q[tail-1].num+(i-q[tail-1].t)*s>=a)--tail;
			q[tail].num=a,q[tail++].t=i;
			while(p<n && i == order[p].t){
				while(q[top].t+t<i)++top;
				sum+=(q[top].num+(i-q[top].t)*s)*order[p++].num;
			}
		}
		printf("%I64d\n",sum);
	}
	return 0;
}

 

5、FZU- Problem 2080

题意：给定一个n*m的矩阵，从其中所有c*r子矩阵的最大值-最小值中选一个最大的作为结果。

思路：

         首先，对于这种统计最值的问题可以用遍历所有元素来解决，但如果是求字串的最值，

遍历的话需要o（n*n）的时间复杂度，所以我们引入了单调队列，其实质就是求一段

序列各种字串的最值。（单调队列最常解决的问题）

        对应到矩阵上来，求所有子矩阵的最值，仍然可以采取遍历的方式，但是时间复杂度

O(N*M*C*R) ,然后另一种求矩阵最值的方案，先求出每列的最值，然后取其中最值就是整

个矩阵的最值（要从整个矩阵上考虑，枚举每一个子阵的话显然更慢），仍然按照朴素算

法来算的话，时间复杂度O（M列*N起点*Len长度*N遍历）+O（N行*M起点*len长度*M遍历）

（该题中Len为固定值，可以忽略），1second肯定TLE了，考虑这实际上就是在求序列字串

的最值，属于单调队列的应用之一，所以对整个矩阵操作，时间复杂度为O（M*N）+O（N*M）

，，，完美。

#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
#include<cmath>
#include<set>
using namespace std;
#define N 1005
int head,tail,mat[N][N],vmax[N][N],vmin[N][N];         
 //vmax[i][j]表示(i,j)到(i+d-1,j+d-1)中的最大值,
//vmin[i][j]表示(i,j)到(i+d-1,j+d-1)中的最小值。
struct node
{
    int num,id;
};
node que[N];
void add_max(int num,int id)
{
    while(head<tail&&que[tail-1].num<=num)tail--;      //单调队列维护
    que[tail].id=id;
    que[tail++].num=num;
}
void add_min(int num,int id)
{
    while(head<tail&&que[tail-1].num>=num)tail--;
    que[tail].id=id;
    que[tail++].num=num;
}
int get_num(int id)
{
    while(head<tail&&que[head].id<id)head++;
    return que[head].num;
}
int main()
{
    //freopen("a.txt","r",stdin);
    int n,m,r,c;
    while(scanf("%d%d%d%d",&n,&m,&r,&c)!=EOF)
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                scanf("%d",&mat[i][j]);
            }
        }
        for(int i=0;i<m;i++)
        {
            head=tail=0;
            for(int j=0;j<r-1;j++)add_max(mat[j][i],j);
            for(int j=r-1;j<n;j++)
            {
                add_max(mat[j][i],j);
                vmax[j-r+1][i]=get_num(j-r+1);          
        //这时的vmax[j-r+1][i]表示第i列中的第j-r+1行到第j行的最大值
            }
        }
        for(int i=0;i<=n-r;i++)
        {
            head=tail=0;
            for(int j=0;j<c-1;j++)add_max(vmax[i][j],j);         
     //这里就是二维单调队列维护了
            for(int j=c-1;j<m;j++)
            {
                add_max(vmax[i][j],j);
                vmax[i][j-c+1]=get_num(j-c+1);
            }
        }
        for(int i=0;i<m;i++)
        {
            head=tail=0;
            for(int j=0;j<r-1;j++)add_min(mat[j][i],j);
            for(int j=r-1;j<n;j++)
            {
                add_min(mat[j][i],j);
                vmin[j-r+1][i]=get_num(j-r+1);
            }
        }
        for(int i=0;i<=n-r;i++)
        {
            head=tail=0;
            for(int j=0;j<c-1;j++)add_min(vmin[i][j],j);
            for(int j=c-1;j<m;j++)
            {
                add_min(vmin[i][j],j);
                vmin[i][j-c+1]=get_num(j-c+1);
            }
        }
        int ans=0;
        for(int i=0;i<=n-r;i++)
        {
            for(int j=0;j<=m-c;j++)
            {
                ans=max(ans,vmax[i][j]-vmin[i][j]);
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

 

The end；

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

_wjunjie
关注
专栏目录
7.4.1 蓝桥杯基础数据结构之单调栈&单调队列
tang7mj的博客
01-30 459
单调栈是一种特殊的栈结构，其主要特点是保持栈内元素的单调性——栈内的元素要么严格递增，要么严格递减。单调栈常用于解决那些需要快速查询一个元素左侧或右侧第一个比它大或比它小的元素的问题。
单调队列的总结（初级）
Maosghoul的博客
07-25 1249
首先应该是说一下单调队列的定义 百科上是这样说的 单调队列 单调队列，即单调递减或单调递增的队列。使用频率不高，但在有些程序中会有非同寻常的作用。   从字面上理解就是一种队列按照递增或者递减的循序排列，最近做数据结构的时候，做了几道单调队列的题，在这里总结一下， 总结的是比较入门的单调队列，不过，单调队列用在更深层的层次应该是在dp优化的层面上。 我们首先看一下下面这个例子： h...
最小区间--单调队列+优先队列
zehong1995的博客
09-04 511
给定k个有序数组, 每个数组有个N个元素，找出一个最小的闭区间，使其包含每个数组中的至少一个元素。 给定两个区间[a,b], [c,d]： 如果 b-a &lt; d-c，则认为[a, b]是更小的区间； 如果 b-a == d-c，且a &lt; c，则认为[a, b]是更小的区间。 输入样例 3 3 2 12 14 2 6 9 4 7 19 按元素大小扔进优先队列，每次弹出最小值...
135 最大子序和（单调队列优化）
二哈
10-04 392
1. 问题描述： 输入一个长度为 n 的整数序列，从中找出一段长度不超过 m 的连续子序列，使得子序列中所有数的和最大。注意： 子序列的长度至少是 1。 输入格式 第一行输入两个整数 n,m。第二行输入 n 个数，代表长度为 n 的整数序列。同一行数之间用空格隔开。 输出格式 输出一个整数，代表该序列的最大子序和。 数据范围 1 ≤ n，m ≤ 300000 输入样例： 6 4 1 -3 5 1 -2 3 输出样例： 7 来源：https://www.acwing.com/proble
【C++】单调队列求特定区间最大值
Mitchell_Donovan的博客
03-22 1912
题目（单调队列的应用）： 用一个长度为k的窗口在长度为n的整数数列上从左往右滑动，每次滑动一个单位，求出每次滑动后每个窗口里面所包含的数的最大值。例如：当数列为[1, 3, -1, -3, 5, 3, 6, 7]，窗口大小k=3，可以得出， 窗口位置 窗口内最大值 [13-1]-35367 3 1[3-1-3]536...
day14:斐波那契数列的几种解法 （拓展：爬楼梯）
yangyangcome的博客
06-24 336
https://www.acwing.com/blog/content/25/ 例题： 输入一个整数 n ，求斐波那契数列的第 n 项。假定从0开始，第0项为0。(n<=39) 样例 输入整数 n=5 ，返回 5。 用到的是大神写的递归+滚动变量。 取模很关键，% 1000000007，不然有的题目无法通过。 class Solution { public: int Fibonacci(int n) { int a=0,b=1; while(n--)
动态规划之单调队列优化专题【附题目练习清单】
剑锋OI SharpSwordOI
12-06 3784
什么是单调（双端）队列 单调队列，顾名思义，就是一个元素单调的队列，那么就能保证队首的元素是最小（最大）的，从而满足动态规划的最优性问题的需求。 单调队列，又名双端队列。双端队列，就是说它不同于一般的队列只能在队首删除、队尾插入，它能够在队首、队尾同时进行删除。 【单调队列的性质】 一般，在动态规划的过程中，单调队列中每个元素一般存储的是两个值： 1.在原数列中的位置（下标） 2....
单调栈算法总结&专题训练
Plozia 的小窝
11-19 535
目前还没有完成。 1.概述 单调栈，是一种数据结构，与单调队列相似。 单调队列使用双端队列维护，队列内元素单调递增或单调递减。 单调栈则使用普通的栈维护，栈内元素单调递增或单调递减。 接下来，通过一道例题，来看一下单调栈的基本操作。 2.例题 link 作为例题，我将会详细讲解单调栈的用法。 单调栈其实类似于单调队列（不了解的可以看一看这篇文章），只不过在维护时不需要考虑元素过时问题。 通常，单调栈分为两种：单调递增栈与单调递减栈。 单调递增栈：栈内元素单调递增。（如 1 2 3） 单调递减栈：栈内元素单
leetcode题库-LeetCode-Topic:LeetCode专题刷题模板分类Java版讲解
06-29
计划把LeetCode分专题总结，每个文件夹对应一个专题 一个专题里内容有两部分： \*\*模板.md: 包含相应专题的知识点，以及我融合网上讲解和我自己的总结得到的模板，以及文件夹下的题目的简要思路 \*\*习题.md：相应...
2019/2/12训练总结 单调栈和二分
胖亚亚的小酒馆
02-12 603
今天补了补前两天单调栈和单调队列专题 和二分专题的题目 单调是一种思想，当我们解决问题的时候发现有许多冗杂无用的状态时， 我们可以采用单调思想，用单调队列或类似于单调队列的方法去除冗杂状态，保存我们想要的状态。 最后再总结一下单调栈。单调栈这种数据结构，通常应用在一维数组上。如果遇到的问题，和前后元素之间的大小关系有关系的话，我们可以试图用单调栈来解决。在思考如何使用单调栈的时候，可以回忆一...
单调队列的一个应用——求解连续区间最大值（HDU Max Sum of Max-K-sub-sequence）
cyb6100300115的专栏
08-02 1727
Description Given a circle sequence A[1],A[2],A[3]......A[n]. Circle sequence means the left neighbour of A[1] is A[n] , and the right neighbour of A[n] is A[1]. Now your job is to calculate the m
HDOJ 题目3415 Max Sum of Max-K-sub-sequence（单调队列求区间和最大值）
Jogging_Clown
09-25 500
Max Sum of Max-K-sub-sequence Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 6698    Accepted Submission(s): 2460 Problem Description
蓝桥杯刷题016——最大子矩阵（尺取法+单调队列）
最新发布
荷叶田田的博客
01-27 1729
没有白走的路，每一步都算数！
Leetcode刷题（Week3）——贪心专题
Meggie的博客
04-08 393
刷题时间： 2019/04/07 – 主播：yxc(闫雪灿) 视频链接： https://www.bilibili.com/video/av32864007/?p=1 题号 题目 链接 860 Lemonade Change https://leetcode.com/problems/lemonade-change/ 392 Is Subsequence https://lee...
解题报告：Fake Maxpooling（单调队列求矩阵的和）
繁凡さん的博客
08-02 508
我们不妨先把这个问题中二维的矩阵简化成一维的数列。那么现在的问题就变成了一个求连续的滑动窗口最值问题：给出一个长度为n的数列和一个长度为k(k<n)的窗口，记录滑动窗口位于每个位置下的下的最大值，求这些最大值和。如果我们先用单调队列，把每一列长度为k的滑动窗口的最大值先预处理出来，就像这样，先变成这么一个k*n的矩阵，然后再用一次单调队列，把每一行中长度为k的滑动窗口中的最大值求出来做一下累加，依旧是正解，但此时，解决这道题的时间复杂度已经被我们降到了O((n−k+1)∗k)O((n-k+1) * .
Leetcode打卡 二叉树的最大深度
mmmm0303的博客
05-24 868
class Solution { public int maxDepth(TreeNode root) { if(root==null){ return 0; } else{ int leftTreeDepth=maxDepth(root.left); int rightTreeDepth=maxDepth(root.right); return jav.
记录week3
qq_24896641的博客
08-09 231
What I Get1、Delete具体实现1）利用post传参数给后台：创建虚拟表单form，不显示，定义method为“post”；增加元素并且将文件名作为value的值；然后提交。 2）删除文件这个操作有风险，需要再次确认是否要删除改文件：利用boostrap模态框实现。 3）进度：完成delete_a.onclick = function DeleteFileAlert() {
暑期LeetCode打卡——Week2，递归
Meggie的博客
04-19 268
刷题时间： 2019/04/19 – 2019/04/19 主播：yxc(闫雪灿) 视频链接： https://v.douyu.com/show/mPyq7oJDm4qv1gLY 题号 | 题目 | 链接 17 | Letter Combinations of a Phone Number | https://leetcode.com/problems/letter-combinations-of...
单调队列优化：动态规划解决滑动窗口问题
章节还提到了一些实际的例子和链接，如1597号题目以及滑动窗口算法总结的文章，这些资源可以帮助读者深入理解并练习运用单调队列优化技巧。例如，1597号问题的链接展示了如何将单调队列的思想应用到具体的滑动窗口...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值