数据结构·堆

合集 - 数据结构(5)

1.数据结构·堆2024-11-20

2.数据结构·ST表2024-11-25 3.数据结构·树状数组2024-11-28 4.数据结构·并查集2024-12-14 5.SAM 学习笔记03-11

堆

~~堆是一种数据结构。没了~~

堆是一种树形结构，堆顶始终保持为所有元素的最优值，所以常常运用于贪心中。

大根堆的根为堆的最大值，小根堆的根为堆的最小值。堆一般用二叉树实现。

【YbtOj】题解

A.合并果子

可以贪心地想到每次选取代价最小的两堆进行合并，再将新的一堆放入所有待选堆中。每次操作用小根堆维护最小代价即可，复杂度 $O (n l o g n)$ 。

关于 $O (n)$ 的做法：我们可以想到，对于新合并成的一堆果子，其代价一定是单调递增的，于是可以用另一个队列存储新合成的果子堆，每次操作取原队列与第二个队列的队头较小值，这样不用堆便维护了队列的单调性。为了确保 $O (n)$ 的复杂度，刚开始直接上简单粗暴的桶排即可。

B.序列合并

用大根堆维护目前所选数的最大值，因为给出序列已具有单调性，所以直接for循环两个指针分别从前往后分别扫两个序列即可。若目前没选够 $n$ 个数，那么直接插入 $a_{i} + b_{j}$ ；若已选够，那么就与目前最大值比较判断是否更优。均摊下来复杂度为 $O (n l o g n)$ ，不会炸（此处存疑）

AC代码

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e5+5;
int n;
int a[N],b[N];
priority_queue <int> q;
stack <int> s;

signed main()
{
	scanf("%lld",&n);
	for (int i=1;i<=n;i++) scanf("%lld",&a[i]);
	for (int i=1;i<=n;i++) scanf("%lld",&b[i]);
	
	for (int i=1;i<=n;i++)
	{
		for (int j=1;j<=n;j++)
		{
			int t=a[i]+b[j];
			if (q.size()<n) {  q.push(t); continue;  }
			if (t<q.top()) {  q.pop(); q.push(t); continue;  }
			break;
		}
	}
	
	while (!q.empty()) {  s.push(q.top()); q.pop();  }
	while (!s.empty()) {  printf("%lld ",s.top()); s.pop();  }
	return 0;
}

C.龙珠游戏

看到神似“删除”的操作，想到链表。用大根堆维护目前队列的最大值，若当前堆顶 $i$ 没有走过且不是队列最后一个元素，那么与 $n x t_{i}$ 一同出队，并链表叽里呱啦操作一下、标记已出队即可。

来自sxht dalao：不用堆优化就能做到 $O (n)$ ，因为 $a$ 中元素两两不同，根据 $a_{i}$ 建链表即可。

AC代码(带无意义的堆优化)

#include <bits/stdc++.h>
#define int long long
#define pii pair<int,int>
#define mp make_pair
using namespace std;
const int N=1e5+5;
int n;
int a[N];
int nxt[N],pre[N];
bool flag[N];
priority_queue <pii> q;
queue <int> ans;

signed main()
{
	scanf("%lld",&n);
	for (int i=1;i<=n;i++) { scanf("%lld",&a[i]); q.push(mp(a[i],i)); }
	for (int i=1;i<n;i++) nxt[i]=i+1;
	for (int i=2;i<=n;i++) pre[i]=i-1;
	
	while (ans.size()<n)
	{
		while (!q.empty()&&(flag[q.top().second]||nxt[q.top().second]==0)) q.pop();
		int t1=q.top().second,t2=nxt[t1];
		flag[t1]=true,flag[t2]=true;
		pre[nxt[t2]]=pre[t1],nxt[pre[t1]]=nxt[t2];
		ans.push(a[t1]),ans.push(a[t2]);
		q.pop();
	}
	
	while (!ans.empty()) {  printf("%lld ",ans.front()); ans.pop();  }
	return 0;
}

D.工作安排

很典的一道反悔贪心。为了能完成尽量多的工作，我们每次肯定是取截止时间更靠前的工作；但若是有一个工作靠前，但获利少，而后面存在一个获利更多的工作，这样的贪心选择就会不那么优。于是我们会想到，每次对于一个获利更多但没时间的工作，将已选的工作中获利最少的替换掉，这样一定是更优的。

所以，刚开始按照截止日期升序排序，用小根堆维护目前已选的最小的 $P_{i}$ 就行。至于选了多少个数？堆内元素数量就是选的数的个数

AC代码

#include <bits/stdc++.h>
#define int long long
#define pii pair<int,int>
using namespace std;
const int N=1e5+5;
int n;
struct node{
	int d,p;
}a[N];
priority_queue < pii,vector <pii>,greater<pii> > q;
int ans;

bool cmp(node x,node y) { return x.d<y.d; }
signed main()
{
	scanf("%lld",&n);
	for (int i=1;i<=n;i++) scanf("%lld%lld",&a[i].d,&a[i].p);
	
	sort(a+1,a+1+n,cmp);
	for (int i=1;i<=n;i++)
	{
		if (q.size()<a[i].d)
		{
			ans+=a[i].p;
			q.push({a[i].p,a[i].d});
		}
		else
		{
			if (a[i].p>q.top().first)
			{
				ans=ans-q.top().first+a[i].p;
				q.pop();
				q.push({a[i].p,a[i].d});
			}
		}
	}
	
	printf("%lld",ans);
	return 0;
}

E.家庭作业

也是很典的一道题呢（让我想起来了一个月前让我痛苦万分的分冰棍！）

先按照截止时间排序，每次尽量不喝奶茶，若对于当前 $d_{i}$ 无法满足，那么前面就一定要喝奶茶了。为了尽量少喝，我们就要选性价比最高的奶茶，用大根堆维护即可；而喝奶茶不能喝到“时光倒流”，所以还需要维护每种奶茶的剩余量。

AC代码

#include <bits/stdc++.h>
#define int long long
#define pii pair<int,double>
#define mp make_pair
using namespace std;
const int N=2e5+5;
int n;
struct node{
	int l,t,d;
}a[N]; 
int tme;
double ans;
priority_queue < pii > q;

bool cmp(node x,node y) {  return x.d<y.d;  } 
signed main()
{
	scanf("%lld",&n);
	for (int i=1;i<=n;i++) scanf("%lld%lld%lld",&a[i].l,&a[i].t,&a[i].d);
	
	sort(a+1,a+1+n,cmp);
	for (int i=1;i<=n;i++)
	{
		q.push(mp(a[i].l,1.0*a[i].t));//又多了一种奶茶 
		tme+=a[i].t;
		while (tme>a[i].d)//还得喝奶茶 
		{
			int fst=q.top().first,d=tme-a[i].d;
			double scd=q.top().second;
			q.pop();
			if (scd>=d)//要补的 
			{
				ans+=1.0*d/(1.0*fst);
				if (scd!=d) q.push(mp(fst,scd-1.0*d));
				tme=a[i].d;
				break;
			}
			else//不够 
			{
				tme-=scd;
				ans+=scd/(1.0*fst);
			}
		}
	}
	printf("%.2lf",ans);
	return 0;
}

F.选数游戏

若选了第 $i$ 列的数，那么它有两种贡献方式：一是使得可以到达 $i$ 后贡献更大的列，二是它的值直接贡献。因此，若一列有取到的数，一定是只选一个或全都选。

于是，从左到右遍历数列，遍历到第 $i$ 列时，从第 $1$ 到 $i$ 列一定都有被选的数，此时 $s u m$ 相当于是选到第 $i$ 列的最大贡献和，所有 $s u m$ 的最大值就是最终答案。

到第 $i$ 列时，将其所有的数都计入 $c n t$ 与 $s u m$ ，若溢出，那么每次去除最小值即可，用小根堆维护。

AC代码

#include <bits/stdc++.h>
#define int long long
#define pii pair<int,int>
using namespace std;
const int N=1e6+5;
int n,m,k;
int a[N];
priority_queue < int,vector <int>,greater<int> > q;
int cnt,sum;
int ans;

signed main()
{
	scanf("%lld%lld%lld",&n,&m,&k);
	for (int i=1;i<=m;i++) scanf("%lld",&a[i]);
	
	int maxx=0;
	for (int i=1;i<=min(m,k);i++)
	{
		q.push(a[i]);
		cnt+=n,sum+=n*a[i];
		while (cnt>k&&!q.empty())
		{
			cnt-=n-1,sum-=(n-1)*q.top();
			maxx=q.top();
			q.pop();
		}
		ans=max(ans,sum+min(n,k-cnt)*maxx);
	}
	
	printf("%lld",ans);
	return 0;
}

G.内存管理

直接模拟即可。小根堆维护当前编号最小的未分配内存块，队列维护被分配的内存块顺序， $t_{i}$ 维护每个已分配内存块最后被操作的时间，每次操作将不合法的编号出队即可。

AC代码

#include <bits/stdc++.h>
#define int long long
#define pii pair<int,int>
#define mp make_pair
#define fst first
#define scd second
using namespace std;
const int N=3e4+5;
int t[N];//对于被占用的内存块i，最后一次被操作的时间
priority_queue < int,vector <int>,greater<int> > q; 
queue <pii> out;

signed main()
{
	for (int i=1;i<=30000;i++) q.push(i);
	
	int x,y;
	char c;
	while (cin>>x>>c)
	{
		while (!out.empty()&&out.front().scd<=x-600)
		{
			if (out.front().scd==t[out.front().fst])
			{
				t[out.front().fst]=0;
				q.push(out.front().fst);
			}
			out.pop();
		}
		if (c=='+')
		{
			cout<<q.top()<<'\n';//分配编号最小的空闲的
			t[q.top()]=x;
			out.push(mp(q.top(),x));
			q.pop(); 
		}
		if (c=='.')
		{
			cin>>y;
			if (t[y]) cout<<'+'<<'\n';
			else cout<<'-'<<'\n';
			if (t[y]) t[y]=x;
			out.push(mp(y,x));
		}
	}
	return 0;
}

H.火车载客

写了n次，果然没我想的那么简单啊啊啊

贪心考虑，一定是让第 $k$ 组所有人上车最优。若所有人都上车人数超过限制，那么对于时间 $[s, t]$ 内车上的人员，需要下车的人数就是 $s u m - c$ （ $s u m$ 表示当前车上人数），而为了最优，一定是使下车时间靠后的人下车，这里就可以用堆维护。

将第 $k$ 组分成上车、下车两部分分别处理。对于第 $i d$ 次，若当前下车，那么就将答案加上该组人数，再将 $s u m$ 减去 $i d$ 的人数；若当前上车，就在限制 $c$ 内尽量往里面塞人。需要注意在塞人前，要提前把在该站下车的人下车，不然会影响塞人。如果 $i d$ 还可以再塞人且更优，那就用第 $i d$ 次的人替换先前不优的人。

AC代码

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N=3e5+5;
int k,n,c;
struct train
{
	int s,t,p,id;//p:还有多少人可上车 id:已上车多少人
	bool operator < (const train &a) const {  return t<a.t;  }
}a[N];
struct node
{
	int tme,id,op;
	bool operator < (const node &a) const 
	{
		if (tme!=a.tme) return tme<a.tme;
		else return op>a.op;
	}
}b[N<<1];
int tol;
priority_queue <train> q;
int ans,sum;

signed main()
{
	scanf("%lld%lld%lld",&k,&n,&c);
	for (int i=1;i<=k;i++)
	{
		scanf("%lld%lld%lld",&a[i].s,&a[i].t,&a[i].p);
		b[++tol]={a[i].s,i,0};
		b[++tol]={a[i].t,i,1};
	}
	
	sort(b+1,b+1+tol);
	for (int i=1;i<=tol;i++)
	{
		int id=b[i].id;
		if (b[i].op==1)
		{
			ans+=a[id].id ,sum-=a[id].id;
			a[id].id=0;
			continue;
		}
		//该下下 
		while (!q.empty()&&q.top().t<b[i].tme) {  a[q.top().id].id=0 ; q.pop();  }
		//尽量上 
		while (sum<c&&a[id].p)
		{
			int add=min(c-sum,a[id].p);
			a[id].id+=add,a[id].p-=add;
			q.push((train){a[id].s,a[id].t,add,id});
			sum+=add;
		}
		//更优就上 
		while (!q.empty()&&a[id].p&&a[id]<q.top())
		{
			train tmp=q.top();
			q.pop();
			
			int add=min(a[id].p,tmp.p);
			tmp.p-=add;
			a[tmp.id].id-=add;
			a[id].id+=add,a[id].p-=add;
			
			if (tmp.p) q.push(tmp);
			q.push((train){a[id].s,a[id].t,add,id});
		}
	}
	printf("%lld",ans);
	return 0;
}

I.矩阵选数

数据存在问题

posted @ 2024-11-20 23:22 还是沄沄沄阅读(12) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 数据结构·并查集

· shr专题

· YbtOJ 「数据结构」第1章堆的应用

· 堆结构和堆排序

· 数据结构 - 堆

阅读排行：
· 地球OL攻略 —— 某应届生求职总结
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· 提示词工程——AI应用必不可少的技术
· .NET周刊【3月第1期 2025-03-02】

公告

昵称：还是沄沄沄
园龄： 4个月
粉丝： 9
关注： 11

+加关注

2025年3月

日

一

二

三

四

五

六

Myyy-L

数据结构·堆

堆

【YbtOj】题解

A.合并果子

B.序列合并

C.龙珠游戏

D.工作安排

E.家庭作业

F.选数游戏

G.内存管理

H.火车载客

I.矩阵选数

公告

搜索

常用链接

合集 (7)

随笔分类 (17)

随笔档案 (50)

阅读排行榜

最新评论