单调队列及其deque写法 HDU 3415+Poj 4002 (日期处理) + 合并果子

最新推荐文章于 2024-04-14 13:56:07 发布
最新推荐文章于 2024-04-14 13:56:07 发布
阅读量1.6k 收藏
点赞数
分类专栏： 数据结构 文章标签： 单调队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whyorwhnt/article/details/18899859
版权

尝试用deque写一下单调队列，发现速度还是可以接受的，STL依赖症越来越严重了。。。。

HDU 3415 Max Sum of Max-K-sub-sequence

题意：给出一个有N个数字（-1000..1000，N<=10^5）的环状序列，让你求一个和最大的连续子序列。这个连续子序列的长度小于等于K。

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
#define upmax(a,b) ((a)=(a)>(b)?(a):(b))

const int N=100005;
int data[N];
int sum[2*N],n,k;
deque <int> Q;

void In (int i)
{//以i为开头的一个区间需要比较和保存i-1
    while (!Q.empty() && sum[Q.back()]>=sum[i-1])   //>也可
        Q.pop_back();
    Q.push_back(i-1);  //记录该元素的前一个下标
}

void Out (int i)
{
    while (!Q.empty() && i-Q.front()>k )
        Q.pop_front();
}

int main ()
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d%d",&n,&k);
        int i;
        if (Q.empty()==false) Q.clear();
        memset(sum,0,sizeof(sum));
        for (i=1;i<=n;i++)
        {
            scanf("%d",&data[i]);
            sum[i]=sum[i-1]+data[i];
        }
        for (;i<=2*n;i++)
            sum[i]=sum[i-1]+data[i-n];

        int s=0,e=0,ans=-9999999;
        for (i=1;i<=n+k;i++)
        {
            In(i);
            Out(i);
            if (ans<sum[i]-sum[Q.front()])
            {
                upmax(ans,sum[i]-sum[Q.front()]);
                s=Q.front()+1;
                e=i;
            }
        }
        if (s>n)
            s=s-n;
        if (e>n)
            e=e-n;
        printf("%d %d %d\n",ans,s,e);
    }
    return 0;
}

/*
6
6 6
0 1 2 3 4 5
6 6
1 2 3 -4 5 6
6 6
2 0 -4 5 6 7
8 8
0 1 2 2 1 0 0 0
51 34
-537 -622 -109 302 420 -955 987 570 138 -7 866 -291 -919 -746 -501 -814 -182 121 174 -919 181 -759 -879 514 222 -392 -452 -581 -150 -278 880 911 202 -401 667 123 109 -296 -961 -761 450 716 355 604 -449 -50 -572 644 -364 339 -475
5 5
-1 -1 -1 -1 0

Out
15 2 6
17 5 3
20 4 1
6 2 5
2724 31 11
0 5 5

*/


#include <cstdio>
#include <cstring>
#define upmax(a,b) ((a)=(a)>(b)?(a):(b))

const int N=100005;
int data[N],Q[2*N];
int sum[2*N],n,k,head,tail;

void In (int i)
{//以i为开头的一个区间需要比较和保存i-1
    while (head<=tail && sum[Q[tail]]>=sum[i-1])  //>也可
        tail--;
    Q[++tail]=i-1;  //记录该元素的前一个下标
}

void Out (int i)
{
    while (head<=tail && i-Q[head]>k)
        head++;
}

int main ()
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d%d",&n,&k);
        int i;
        memset(sum,0,sizeof(sum));
        for (i=1;i<=n;i++)
        {
            scanf("%d",&data[i]);
            sum[i]=sum[i-1]+data[i];
        }
        for (;i<=2*n;i++)
            sum[i]=sum[i-1]+data[i-n];

        head=0;tail=-1;
        int s=0,e=0,ans=-9999999;
        for (i=1;i<=n+k;i++)
        {
            In(i);
            Out(i);
            if (ans<sum[i]-sum[Q[head]])
            {
                upmax(ans,sum[i]-sum[Q[head]]);
                s=Q[head]+1;
                e=i;
            }
        }
        if (s>n)
            s=s-n;
        if (e>n)
            e=e-n;
        printf("%d %d %d\n",ans,s,e);
    }
    return 0;
}

Poj 4002 & Hdu 4122 Alice's mooncake shop

题意：一个生产月饼的工厂，给出一个数m，该工厂只在前m小时（也就是[1,m]）生产月饼。给出一系列订单，订单给出在第i小时买家要拿走R数量的月饼(1<=i<=m)。生产一个月饼的单价每天不同。工厂有一个冰箱，可以将提前生产的月饼放在冰箱里（工厂也可以在订单到来的那个时刻生产，生产月饼可以瞬间完成），但是放在冰箱里的时间不能超过T。每个月饼在冰箱里保存一天需要额外的费用S。制定工厂的生产计划使得总花费最少？冰箱无限大，每小时生产月饼数量没有限制。

思路：维护一个单调队列，把时间都转化成从2000年第一个月第一天的0时开始

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;


const int N=100005;

int n,m,S,T,p[N]; //p数组表示该时刻的成本
int hour[2505];   //每项请求所在的时间,以小时表示
int R[2505];

char map[12][4]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};

int M[2][13]=
{
	{0,31,28,31,30,31,30,31,31,30,31,30,31},
	{0,31,29,31,30,31,30,31,31,30,31,30,31}
};

int Y[]={365,366};

int getMonth (char s[])
{
	int i;
	for (i=0;i<12;i++)
		if (strcmp(map[i],s) == 0)
			break;
	return i+1;
}

int Is_Year (int x)
{//闰年返回1,否则返回0
	return x%400==0 || x%100 && x%4==0;
}

void Input ()
{
	char str[15];
	int day,year,H,i,j;
	for (i=1;i<=n;i++)
	{
		scanf("%s %d %d %d %d",str,&day,&year,&H,&R[i]);
		int month=getMonth(str);
		int ans=0;
		for (j=2000;j<year;j++)
			ans+=Y[Is_Year(j)];
		int t=Is_Year(year);
		for (int j=1;j<month;j++)
			ans+=M[t][j];
		ans+=day-1;
		hour[i]=ans*24+H+1;
	}
	scanf("%d%d",&T,&S);
	for (i=1;i<=m;i++)
		scanf("%d",&p[i]);
}

struct Node
{
	int x,y;//x制作时的单价,y制作时的时刻
}tmp;
deque<Node> Q;

int main ()
{
	while (scanf("%d%d",&n,&m),n||m)
	{
		Input ();
		Q.clear();
		__int64 ans=0;
		int head=0,tail=-1;
		int id=1;
		for (int i=1;i<=m;i++)
		{//维护单增队列,队首元素一定单价最小
		    while (!Q.empty() && Q.back().x+(i-Q.back().y)*S >= p[i])
                Q.pop_back();
            tmp.x=p[i];
            tmp.y=i;
            Q.push_back(tmp);
			while (id<=n && hour[id]==i)
			{
			    while (!Q.empty() && Q.front().y+T<i) //超出保存期限,删除队头元素
                    Q.pop_front();
				ans+=((__int64)(Q.front().x+(i-Q.front().y)*S))*R[id];
				id++;
			}
		}
		printf("%I64d\n",ans);
	}
	return 0;
}
/*
2 12
Jan 1 2000 9 10
Jan 1 2000 10 10
5 2
20
20
20
10
10
8
7
9
5
10
15
13
0 0

OUT
160
*/


#include <cstdio>
#include <cstring>
#include <cstdlib>

const int N=100005;

int n,m,S,T,p[N]; //p数组表示该时刻的成本
int hour[2505];   //每项请求所在的时间,以小时表示
int R[2505];

char map[12][4]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};

int M[2][13]=
{
	{0,31,28,31,30,31,30,31,31,30,31,30,31},
	{0,31,29,31,30,31,30,31,31,30,31,30,31}
};

int Y[]={365,366};

int getMonth (char s[])
{
	int i;
	for (i=0;i<12;i++)
		if (strcmp(map[i],s) == 0)
			break;
	return i+1;
}

int Is_Year (int x)
{//闰年返回1,否则返回0
	return x%400==0 || x%100 && x%4==0;
}

void Input ()
{
	char str[15];
	int day,year,H,i,j;
	for (i=1;i<=n;i++)
	{
		scanf("%s %d %d %d %d",str,&day,&year,&H,&R[i]);
		int month=getMonth(str);
		int ans=0;
		for (j=2000;j<year;j++)
			ans+=Y[Is_Year(j)];
		int t=Is_Year(year);
		for (int j=1;j<month;j++)
			ans+=M[t][j];
		ans+=day-1;
		hour[i]=ans*24+H+1;
	}
	scanf("%d%d",&T,&S);
	for (i=1;i<=m;i++)
		scanf("%d",&p[i]);
}

struct Node
{
	int x,y;//x制作时的单价,y制作时的时刻
}Q[N];

int main ()
{
	while (scanf("%d%d",&n,&m),n||m)
	{
		Input ();
		__int64 ans=0;
		int head=0,tail=-1;
		int id=1;
		for (int i=1;i<=m;i++)
		{//维护单增队列,队首元素一定单价最小
			while (head<=tail && Q[tail].x+(i-Q[tail].y)*S >= p[i])
				tail--;
			tail++;
			Q[tail].x=p[i];
			Q[tail].y=i;
			while (id<=n && hour[id]==i)
			{
				while (head<tail && Q[head].y+T<i)  //超出保存期限,删除队头元素
					head++;
				ans+=((__int64)(Q[head].x+(i-Q[head].y)*S))*R[id];
				id++;
			}
		}
		printf("%I64d\n",ans);
	}
	return 0;
}


Hdu 4193 Non-negative Partial Sums

在这里Hdu4193 Non-negative Partial Sums (单调队列) - whyorwhnt的专栏 - 博客频道 - CSDN.NET

已经总结过一次了，这里补一个deque写法

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;

const int N=1000005;

int data[N],sum[2*N];
int n,ans;
deque<int> Q;

void In (int i)
{//单调递增队列,保证队首最小
    while (!Q.empty() && sum[Q.back()]>=sum[i])
        Q.pop_back();
    Q.push_back(i);
}

void Out (int i)
{
    if (Q.front()<=i-n) Q.pop_front();
    if (sum[Q.front()]-sum[i-n]>=0) //区间内最小的元素>=区间第一个元素
        ans++;
}

int main ()
{
	while (scanf("%d",&n),n)
	{
	    Q.clear();
		ans=0;
		memset(sum,0,sizeof(sum));
		int i;
		for (i=1;i<=n;i++)
		{
			scanf("%d",&data[i]);
			sum[i]+=sum[i-1]+data[i];
		}
		for (;i<2*n;i++)
			sum[i]+=sum[i-1]+data[i-n];
		for (i=1;i<n;i++)
			In (i);
		for (i=n;i<2*n;i++)
		{
			In(i);
			Out(i);
		}
		printf("%d\n",ans);
	}
	return 0;
}

合并果子

题目链接：https://vijos.org/p/1097

以下分析摘自：http://www.cnblogs.com/neverforget/archive/2011/10/13/ll.html

这个题目非常的经典，方法也很多，可以采用快排或者堆，其思想都是选取当前最小的两个堆进行合并。复杂度均为O(nlogn)，如果用有序队列维护，时间复杂度为O（n）。

每次选取进行合并的两堆，不是最先给定的堆，就是合并最初堆若干次后得到的新堆，所以需要维护两个单调递增队列，一个队列存最初给定的堆的值（1），一个存合并后得到的新值（2）。

每次选择时有三种状态：

1.选取队一的队首两个

2.选取队2的的队首两个

3.选取二者队首各一个

只需对每个队列的指针做相应的更改。

特别注意初始化。

这道题很好的运用了题目中决策的单调性，对初始对经行排序，保证了其单调性。而对于新产生的堆来说，一旦有新元素加入其中，则新元素一定大于原有元素。（很显然，由于队列1的单调性）。

也就是说，队列的单调性是自然而然的。是不需要维护的。要善于观察分析，才能发现。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N=10005;

int data[N],Q[N];

int main ()
{
    int n;
    while (~scanf("%d",&n))
    {
        int i,front,head,tail;
        memset(Q,0x3f3f3f3f,sizeof(Q));
        memset(data,0x3f3f3f3f,sizeof(data));
        for (i=0;i<n;i++)
            scanf("%d",&data[i]);
        if (n==1)
        {
            printf("%d\n",data[0]);
            continue;
        }
        sort(data,data+n);
        head=tail=front=0;
        int sum=0;
        for (i=1;i<=n-1;i++)
        {
            int tmp=0;
            if (data[front]<Q[head])
            {
                tmp+=data[front];
                front++;
            }
            else
            {
                tmp+=Q[head];
                head++;
            }
            if (data[front]<Q[head])
            {
                tmp+=data[front];
                front++;
            }
            else
            {
                tmp+=Q[head];
                head++;
            }
            sum+=tmp;
            Q[tail]=tmp;
            tail++;
        }
        printf("%d\n",sum);
    }
    return 0;
}





时雨晴天
关注
专栏目录
深入浅出单调栈与单调队列
⚡
02-11 7469
深入浅出单调栈与单调队列
合并果子 单调队列的模板题
CutieDeng的博客
01-19 683
题目描述 在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。 每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。 因为还要花大力气把这些果子搬回家，所以多多在合并果子时要
合并果子【单调队列】
Job_yi的专栏
08-20 2461
【问题描述】  在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。     每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。     因为还要花大力气把这些果子搬回家，所以多多在合并果
【单调队列】合并果子
weixin_30470643的博客
07-18 140
题目描述 在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。 每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。 因为还要花大力气把这些果子搬回家，所以多多在合并果子时要尽可...
Luogu1090合并果子[单调队列]
huhao的博客
02-25 727
单调队列(^v^)
单调队列用法 deque
lllzzzhhh2589的记录
12-22 289
deque 是 double-ended queue 的缩写，又称双端队列容器。 和 vector 不同的是，deque 还擅长在序列头部添加或删除元素，所耗费的时间复杂度也为常数阶O(1)。并且更重要的一点是，deque 容器中存储元素并不能保证所有元素都存储到连续的内存空间中。 当需要向序列两端频繁的添加或删除元素时，应首选 deque 容器。 deque 容器以模板类 deque（T 为存储元素的类型）的形式在 头文件中，并位于 std 命名空间中。因此，在使用该容器之前，代码中需要包含下面两行代码
C++ STL deque(双端队列)-＞单调队列 使用方法
最新发布
qq_61252495的博客
04-14 1541
为啥能用单调队列做?当时在学习单调队列的时候 我也抱着这样的一个疑惑 ,那这就要从单调队列的性质说起了.std::deque 是 C++ STL 库 提供的一种 双端队列 其。有了上面的一些常用操作,做题也就够用了 ,deque的一种经典应用就是。的窗口 窗口从第一个元素开始向后移动 要求输出每次窗口中的。个单位 然后算出最大值和最小值存到数组里最后再输出。最大值 也是同样的操作方法。个元素和一个 长度为。: 判断队列是否为空。:返回对首元素的值(:返回队尾元素的值(只有两个测数据集没过。
HDU-3415 单调队列
羽翼的博客
03-01 455
首先单调队列就是具有单调性的队列。。。 算了不废话了，关于单调队列这里有一个对于初学者来说简单明了的博客：链接 具体步骤： 　若队列为空，将A[i]从队尾入队 若队列不为空，将比A[i]大的元素都从队尾弹出，然后把A[i]入队 若队列不为空且A[i]大于队尾，则直接从队尾把A[i]入队 if(q.empty()) q.push_back(A[i]); else if...
单调队列/栈与双向队列集合
10-02
单调队列和单调栈是两种在算法和数据结构领域中常用的工具，它们是基于普通队列和栈的扩展，主要用于处理有序序列中的某些特定问题，如最值查询、滑动窗口最大值或最小值等。这里我们将深入探讨这两种数据结构及其...
单调队列deque
qq_43543296的博客
03-13 1890
文章目录滑动窗口题目代码知识点补充 滑动窗口 题目 给定一个大小为 n≤10^6 的数组。有一个大小为 k 的滑动窗口，它从数组的最左 边移动到最右边。你只能在窗口中看到 k 个数字。每次滑动窗口向右移动一个位 置。以下是一个例子： 该数组为 [1 3 -1 -3 5 3 6 7]，k 为 3。 你的任务是确定滑动窗口位于每个位置时，窗口中的最大值和最小值。 输入样例： 8 3 1 3 -1 -3 5 3 6 7 输出样例： -1 -3 -3 -3 3 3 3 3 5 5 6 7 代码 #include&
单调队列（deque实现）
weixin_46160914的博客
07-10 195
单调队列一般用于求区间内的最值问题 例题： P1886 滑动窗口 P2032 扫描 算法核心 维护一个单调递增或递减的双端队列 队头即是区间的最值 用一个结点存下标和值 struct node { int index; int value; }no; 为了维护单调性需要进行删尾操作 while(!dq.empty()&&dq.back().value<=x) dq.pop_back(); 更新区间最值需要进行去头操作 if(!dq.empty()&&a
单调队列+STL deque
leolin_的专栏
08-06 3149
单调队列=双端队列！ 我们从最简单的问题开始： 给定一个长度为N的整数数列a(i),i=0,1,...,N-1和窗长度k. 要求：       f(i) = max{a(i-k+1),a(i-k+2),..., a(i)},i = 0,1,...,N-1 问题的另一种描
POJ 2823 Sliding Window(单调队列)
@steveyg
08-12 600
Sliding Window Time Limit: 12000MS   Memory Limit: 65536K Total Submissions: 38794   Accepted: 11490 Case Time Limit: 5000MS Description An array of size n ≤ 106 is
CSU-1588 合并果子（堆/单调队列）
Paulliant的博客
07-23 305
题意 有 nnn 堆果子，第 iii 堆果子有 aiaia_i 个，每次合并的代价是两堆果子个数的总和，求总合并的最小代价。 1≤n≤10001≤n≤10001 \leq n \leq 1000 思路 堆（优先队列）的做法已经众所周知，复杂度是不可避免的 O(nlogn)O(nlogn)O(nlogn) 。但如果用单调队列，可以在 O(n)O(n)O(n) 的复杂度中解决。 不难发现，每...
单调队列（数组 / deque）
人工智能方向，计算机视觉
05-04 415
模板题：滑动窗口 STL（deque）实现： #include<cstdio> #include<algorithm> #include<deque>//双端队列 #define foo(i,a,b) for(int i=a;i<=b;i++) using namespace std; const int maxn=1e6+7; int a[maxn]; ...
单调队列-原理详解(deque实现)
热门推荐
Gaoithe的博客
05-30 1万+
一、单调队列的概念： 单调队列，即单调递减或单调递增的队列。 二、单调队列的性质： 1. 队列中的元素在原来的列表中的位置是由前往后的(随着循环顺序入队)。 2. 队列中元素的大小是单调递增或递减的。 三、单调队列的特点： 从队尾入列，队首或队尾出列。 四、例题分析： 那么单调队列用什么用呢？单调队列一般用于求区间内的最值问题。看几道题，理解上述内容： 1. 洛谷P1886 ...
【模板】deque实现单调队列
weixin_30768661的博客
05-22 182
双端队列deque容器： 关于deque最常用的有这几个函数： 都是成员函数 双端队列模板题：【洛谷】P2952 [USACO09OPEN]牛线Cow Line 1 #include<iostream> 2 #include<cstdio> 3 #include<cstring> 4 #include<algorithm&...
Python实战：详解队列数据结构及其 deque应用
在Python算法应用实战中，队列是一个至关重要的数据结构，它遵循先进先出（FIFO，First-In-First-Out）原则，常用于需要按照特定顺序处理任务或数据流的场景。队列的实现通常基于链表或数组，支持在后端（rear）进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值