codeforces 600E - Lomsat gelral（留坑）

最新推荐文章于 2022-03-19 19:18:11 发布
最新推荐文章于 2022-03-19 19:18:11 发布
阅读量385 收藏
点赞数
分类专栏： ————数据结构————— 平衡树 ————莫队—————— 树 ————dsu—————— ————启发式合并———
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Brian551/article/details/78327526
版权

nlog^2的平衡树启发式合并

我写挂了QAQ

T了

留坑待补。。

#include<cstdio>
#include<cstring>
#include<cstdlib>
const int N=1e5+7;
int a[N];
struct edgt
{
	int color,l,r,w,rnd;
}tr[N];
int cnt;
int stack[N+100],top;
inline void rturn(int &k)
{
	int t=tr[k].l;tr[k].l=tr[t].r;tr[t].r=k;
	k=t;
}
inline int read()
{
	int ans=0;char t=getchar();
	while(t<'0'||t>'9')	t=getchar();
	while(t>='0'&&t<='9')	ans=ans*10+t-'0',t=getchar();
	return ans;
}
inline void lturn(int &k)
{
	int t=tr[k].r;tr[k].r=tr[t].l;tr[t].l=k;
	k=t;
}
#define lson tr[k].l
#define rson tr[k].r
void insert(int &k,int num,int tot)
{
	if(!k){
		k=stack[top--];tr[k].color=num;tr[k].rnd=rand();tr[k].w=tot;
		return;
	}
	if(tr[k].color==num)	tr[k].w+=tot;
	else if(num<tr[k].color){
		insert(tr[k].l,num,tot);if(tr[lson].rnd<tr[k].rnd)	rturn(k);
	}	
	else{
		insert(tr[k].r,num,tot);if(tr[rson].rnd<tr[k].rnd)	lturn(k);
	}
}
void dfstree(int &ro,int k)
{
	if(!k)	return;
	insert(ro,tr[k].color,tr[k].w);	
	dfstree(ro,lson);
	dfstree(ro,rson);
	stack[++top]=k;
	tr[k].l=0,tr[k].r=0;
}	
int maxans;
long long sum; 
void dfs2(int k)
{
	if(!k) return ;
	if(tr[k].w>maxans)	maxans=tr[k].w,sum=tr[k].color;
	else if(tr[k].w==maxans)	sum+=tr[k].color;
	dfs2(lson);dfs2(rson);
}
struct node
{
	int to,next;
}e[N*2];
int first[N];
inline void insert_edgt(int u,int v)
{
	e[++cnt]=(node){v,first[u]};first[u]=cnt;
	e[++cnt]=(node){u,first[v]};first[v]=cnt;
}
int size[N];
long long ans[N];

int rt[N];
//void test(int k)
//{
//	if(!k)	return;
//	printf("%d %d\n",tr[k].color,tr[k].w);
//	test(lson);
//	test(rson);
//}
void dfs(int x,int fa)
{
	size[x]=1;
	int max=0,pos=-1;
	for(int k=first[x];k;k=e[k].next)
	if(e[k].to!=fa)
	{
		dfs(e[k].to,x);
		size[x]+=size[ e[k].to ];  
		if(size[e[k].to]>max)	max=size[e[k].to],pos=e[k].to;
	}
	if(pos!=-1)	rt[x]=rt[pos];
	 insert(rt[x],a[x],1);
//	 	 if(x==1)printf("std::\n"),test(rt[1]);;
	for(int k=first[x];k;k=e[k].next)
	if(e[k].to!=fa&&e[k].to!=pos)
	{
//		if(e[k].to==6&&x==1)	printf("aaaaaa %d %d\n",stack[top],top),test(rt[e[k].to]);
		dfstree(rt[x],rt[e[k].to]);
		rt[e[k].to]=0;
//		if(x==1)printf("std::%d\n",e[k].to),test(rt[x]);;
	}
	maxans=0,sum=0;
	dfs2(rt[x]);
	ans[x]=sum;
}
int main()
{
	srand(232);
	int n=read();
	for(int i=1;i<=n;i++)	a[i]=read();
	for(int i=1;i<=n+7;i++)	stack[i]=i;
	top=n+7;
	for(int i=1;i<n;i++){	
		int u,v;u=read(),v=read(),insert_edgt(u,v);
	}
	dfs(1,-1);	
	for(int i=1;i<=n;i++)	printf("%I64d ",ans[i]);
	return 0;
}

dsu on tree:

参考资料：传送门 ||传送门

其实就是个大暴力！

但由于轻重链剖分启发式合并的运用，所以复杂度是nlogn的

我们先预处理出每个点的重儿子

然后开始dfs

先递归下去处理轻儿子（在轻儿子的dfs过程中会删除该子树的贡献）

再处理重儿子（在重儿子的dfs过程中不会删除该子树的贡献）

最后再重新dfs（另一个函数update）一遍把轻儿子的贡献加起来（注意此时不要加重儿子的，因为已经保留了）

记录该节点的ans

然后如果该点是它的父亲的轻儿子，那么我们再dfs一遍把贡献删去（update）

实测78 ms

#include<cstdio>
#include<cstring>
inline int read()
{
	int ans=0;char t=getchar();
	while(t<'0'||t>'9')	t=getchar();
	while(t>='0'&&t<='9')	ans=ans*10+t-'0',t=getchar();
	return ans;
}
const int N=1e5+7;
int a[N];
struct node
{
	int to,next;
}e[N*2];
int cnt,first[N];
inline void insert(int u,int v)
{
	e[++cnt]=(node){v,first[u]};first[u]=cnt;
	e[++cnt]=(node){u,first[v]};first[v]=cnt;
}
int size[N],heavy[N],tar[N];
void count(int x,int fa)
{
	size[x]=1;int max=0,pos=-1;
	for(int k=first[x];k;k=e[k].next)
	if(e[k].to!=fa)	
	{
		count(e[k].to,x),size[x]+=size[e[k].to];
		if(size[e[k].to]>max)	max=size[e[k].to],pos=e[k].to;
	}
	heavy[x]=pos;
	if(pos!=-1)tar[pos]=1;
}
long long ans[N];
int color[N],max;
long long sum;
void update(int x,int fa,int num)
{
	color[a[x]]+=num;
	if(num>0)
	{
		if(color[a[x]]>max)	max=color[a[x]],sum=a[x];
		else if(color[a[x]]==max)	sum+=a[x];
	}
	for(int k=first[x];k;k=e[k].next)
	if(e[k].to!=fa&&e[k].to!=heavy[x])	update(e[k].to,x,num);
}
void dfs(int x,int fa)
{
	for(int k=first[x];k;k=e[k].next)
	if(e[k].to!=fa&&e[k].to!=heavy[x])
	dfs(e[k].to,x);
	
	if(heavy[x]!=-1)		dfs(heavy[x],x);
	update(x,fa,1);
	heavy[x]=0;
	ans[x]=sum;
	
	if(!tar[x])	update(x,fa,-1),max=0;	
}
int main()
{
	int n=read(),u,v;
	for(int i=1;i<=n;i++)	a[i]=read();
	for(int i=1;i<n;i++)	u=read(),v=read(),insert(u,v);
	count(1,-1);
//	for(int i=1;i<=n;i++)	printf("aa%d %d\n",heavy[i],tar[i]);
	dfs(1,-1);
	for(int i=1;i<=n;i++)	printf("%lld ",ans[i]);
	return 0;
}




由于子树的dfs序是连续的

因此我们可以在dfs序上用莫队处理区间询问

如果要支持删除操作的话就得加数据结构，并且复杂度带一个log

所以我们考虑不带删除的莫队

对于左右端点在一个块的，我们直接for求出答案，单个询问复杂度sqrt(n)

对于左端点在块内，右端点在另一块的

因为右端点是递增的，我们直接和原来一样递增扫过去

同时左端点处从块的最右边暴力扫过去

然后再消除影响

左端点由于移动范围最多sqrt（n），n个询问

而右端点每个块最多O（n），sqrt（n）个块

所以总的复杂度还是nsqrt(n)的

实测124 ms

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
inline int read()
{
	int ans=0;char t=getchar();
	while(t<'0'||t>'9')	t=getchar();
	while(t>='0'&&t<='9')	ans=ans*10+t-'0',t=getchar();
	return ans;
}
const int N=1e5+7;
int a[N];
struct node
{
	int to,next;
}e[N*2];
struct edgt
{
	int l,r,order;
}f[N];
int pos[N];
bool cmp(edgt a,edgt b)
{
	if(pos[a.l]==pos[b.l])		return a.r<b.r;
	return pos[a.l]<pos[b.l];
}
int cnt,first[N];
inline void insert(int u,int v)	
{
	e[++cnt]=(node){v,first[u]};first[u]=cnt;
	e[++cnt]=(node){u,first[v]};first[v]=cnt;
}
int qu[N];
void dfs(int x,int fa)
{
	qu[++cnt]=x;f[x].l=cnt;f[x].order=x;
	for(int k=first[x];k;k=e[k].next)
	if(e[k].to!=fa)	dfs(e[k].to,x);
	f[x].r=cnt;
}
int n;
long long ans[N];
int sum[N],color[N],block_right[N];
void work()
{
	int max=0,premax=0;
	long long sum=0,presum=0;
	int r=block_right[1];
	for(int i=1,now=1;i<=n;i++)
	{
		if(f[i].l>block_right[now])	
		{
			memset(color,0,sizeof(color));
			max=0;sum=0;now++;
			while(pos[f[i].l]>block_right[now])	now++;
			r=block_right[now];
		}
//		printf("kkk::%d %d\n",i,now);
		if(f[i].r<=block_right[now])
		{
//			max=0,sum=0;
//			printf("aaaa%d\n",i);
			for(int kk=f[i].l;kk<=f[i].r;kk++)
			{
				color[ a [ qu[kk] ] ]++;
				if(color[ a [ qu[kk] ] ]>max)	max=color[ a[ qu[kk] ] ],sum=a[ qu[kk] ];
				else if(color[ a [ qu[kk] ] ]==max)	sum+=a[ qu[kk] ];
			}
			for(int kk=f[i].l;kk<=f[i].r;kk++)	color[ a [ qu[kk] ] ]--;
			ans[f[i].order]=sum;
			max=0;sum=0;
		}
		else
		{
			while(r<f[i].r)
			{
				r++;color[ a [ qu[r] ] ]++;
				if(color[ a [ qu[r] ] ]>max)	max=color[ a[ qu[r] ] ],sum=a[ qu[r] ];
				else if(color[ a [ qu[r] ] ]==max)	sum+=a[ qu[r] ];
			}	
			premax=max,presum=sum;
			int l=block_right[now]+1;
			while(l>f[i].l)
			{
				l--;color[ a[ qu[l] ] ]++;
				if(color[ a[ qu[l] ] ]>max)	max=color[ a[ qu[l] ] ],sum=a[ qu[l] ];
				else if(color[ a[ qu[l] ] ]==max)	sum+=a[ qu[l] ];
			}
			ans[f[i].order]=sum;
			max=premax,sum=presum;
			while(l<block_right[now]+1)		color[ a [ qu[l] ] ]--,l++;
		}
	}
}
int main()
{
	int u,v;
	n=read();
	for(int i=1;i<=n;i++)	a[i]=read();
	for(int i=1;i<n;i++)	u=read(),v=read(),insert(u,v);
	cnt=0;
	dfs(1,-1);
	int block=sqrt(n); 	
	for(int i=1;i<=n;i++)	pos[i]=(i-1)/block+1;
	for(int i=1;i<=n;i++)
	{
		block_right[i]=i*block;
		if(block_right[i]>=n)	{
			block_right[i]=n;break;
		}
	}
//	for(int i=1;i<=n;i++)	printf("%d ",qu[i]);
//	for(int i=1;i<=n;i++)	printf("std::%d %d %d\n",f[i].l,f[i].r,f[i].order);
//	printf("\n\n");
	std::sort(f+1,f+1+n,cmp);
//	for(int i=1;i<=n;i++)	printf("std::%d %d\n",f[i].l,f[i].r);
	work();
	for(int i=1;i<=n;i++)	printf("%lld ",ans[i]);
	return 0;
}


Brian551
关注
专栏目录
codeforces 600E. Lomsat gelral
ccsu_cat
11-13 295
E. Lomsat gelral 题意：给一棵树，每个节点有一个编号，求每颗子树最多编号的和。 线段树合并模板题 #include&lt;cstdio&gt; #include&lt;algorithm&gt; #include&lt;vector&gt; using namespace std; typedef long long ll; const int maxn=1e5+10; v...
Codeforces 600E Lomsat gelral(启发式合并)
Miracle_ma的专栏
09-05 826
一棵树，每个点一个颜色，问你u节点为根的子树上，颜色出现最多的那些颜色的和一棵树，每个点一个颜色，问你u节点为根的子树上，颜色出现最多的那些颜色的和 启发式合并，每个节点开map，cnt[u][i]表示u节点为根的子树上，i颜色出现多少次启发式合并，每个节点开map，cnt[u][i]表示u节点为根的子树上，i颜色出现多少次 sum[u][i]表示u节点为根的子树上，出现i次的颜色和sum[u]
Codeforces 600E. Lomsat gelral(树上启发式合并)
Rain
08-29 754
题意： n个点的有根树，以1为根，每个点有一种颜色。我们称一种颜色占领了一个子树当且仅当没有其他颜色在这个子树中出现得比它多。求占领每个子树的所有颜色之和。 题解： 树上启发式合并, [Tutorial] Sack (dsu on tree) - Codeforces #include using namespace std; #define N 100005 #defin
codeforces - 600E Lomsat gelral
青烟绕指柔的博客
09-12 232
题目链接：Lomsat gelral 题目大意：就是求任意一个子树的出现最多的颜色的值，如果出现次数一样则累加。 然后就是一道树上启发式合并的裸题啦！ 我们每次用重链维护信息，往上传递，其他信息暴力更新即可。 AC代码： #pragma GCC optimize(2) #include<bits/stdc++.h> #define int long long using name...
Codeforces 600E :Lomsat gelral（启发式合并）
DZYO的博客
12-25 410
传送门 题意： 给一棵树，每个点有一个颜色，定义一个点的权值为其子树中最多的颜色（若有多个则是他们的和），求每个点的权值。 题解： 好题 首先可以Splay启发式合并一波，可以得到理论上的O(nlogn)O(n\log n)复杂度，不过有一种跑得飞快的启发式合并方法，（实际复杂度也是O(nlogn)O(n\log n)的）。 考虑对这棵树树链剖分。显然一个节点会贡献给所有的祖先，那么考
Codeforces Enhancer-crx插件
04-02
语言:English 使Codeforce更好：多个评分图表，为排行榜增色，添加...Chrome扩展程序使Codeforces更好：支持多个评分图表，通过使用的编程语言对排名进行着色，在“问题集”页面添加“隐藏/显示已解决的问题”链接
CodeForces Filter-crx插件
04-02
CodeForces Filter-crx插件是一款专为编程竞赛平台CodeForces设计的浏览器扩展程序，其主要功能是帮助用户过滤掉那些低评级用户的评论。这款插件特别适用于那些希望专注于高质量讨论，避免受到无关或者质量较低的...
Codeforces Mongolia-crx插件
04-03
codeforces.com蒙古语翻译翻译 codeforces.com策略。 - 粉红色的星星似乎在蒙古翻译的杆面前被问题和比赛仪表板翻译。 - 打开粉红色明星或翻译政策的翻译，策略句子将被策略句子翻译为低于策略名称。 - 只能读取...
Codeforces Toolkit-crx插件
04-03
Codeforces工具包可帮助您实现这一目标！ 无需再寻找正确的解决方案，只需将其粘贴到自定义测试运行器中，然后针对您的自定义输入运行即可。 只需停留在同一页面上，然后使用codeforces工具包即可！
Codeforces Notification-crx插件
03-15
When you submit your answers on Codeforces, you can get notification which describes whether you have the correct answer or wrong answer, or so. Codeforcesで答えを提出した時、結果のプッシュ通知を受け...
CodeForces 600E Lomsat gelral（树形dp+启发式合并）
GODSPEED
04-23 1101
题意：给出一棵树，每个节点有一个颜色，求每个节点的子树中颜色数目最多的颜色的和。 思路：如果开n^2的数组记录每个节点子树中出现的颜色的次数那么时空复杂度都会达到O(N^2)，无法承受 现在考虑用map来记录每个节点每个颜色出现的数量，用另一个map记录每个结点中出现某个次数的颜色和，然后用启发式合（合并两个结点时遍历小的合并到大的上）并使时间复杂度降到O(n*logn*logn)，空间复杂度
CodeForces - 600E（树上启发式合并）
qq_41856950的博客
07-08 191
CF600E 题解：维护两个map，见代码 #include<bits/stdc++.h> using namespace std; typedef long long LL; const LL maxn=1e5+10; int n; LL c[maxn]; map<int,int> cnt[maxn];//cnt[x][i]=ko表示x节点子树颜色为i出现ko次 map<int,LL> sum[maxn];//sum[x][i]=ko表示x节点子树颜色出现次数为i次
CodeForces - 600E Lomsat gelral(树上启发式合并)
Falcon的博客
01-14 332
题目链接：点击查看 题目大意：给出一棵树，每个节点都有一个编号代表一种颜色，现在对于每个子树求出现最多的颜色的编号之和 题目分析：因为n给到了1e5，看完这个题第一反应就是暴力n*n，但显然是会超时的，既然是在树上那么考虑用树链剖分+线段树优化，可还不是最优解，用树上莫队也不太行，莫队会带着一个根号，我们需要带着log，于是就学习了一波树上启发式合并，时间复杂度只有nlogn，原理就是利用子树...
codeforces600E. Lomsat gelral(dsu on tree)
Coco_T的博客
08-24 405
You are given a rooted tree with root in vertex 1. Each vertex is coloured in some colour. Let’s call colour c dominating in the subtree of vertex v if there are no other colours that appear in the su
Codeforces 600E. Lomsat gelral [dsu on tree]
sillyf的博客
01-15 324
题解传送门 新姿势 dsu on tree 模板题 #include #include #include #define N 100005 #define LL long long using namespace std; vectorint>e[N]; int n,c[N],sz[N],son[N],num[N],mx; LL ans[N],sum; bool vis[N]; inli
[Codeforces600E]Lomsat gelral（dsu on the tree）
zyf2000
03-07 1343
题目描述传送门 题意：一棵树，每一个点有一个颜色，统计以每一个节点为根的子树中出现次数最多的颜色的编号和。题解学习了一下dsu on the tree，安利一下Yveh的良心博客：http://blog.csdn.net/qaq__qaq/article/details/53455462 算法的大致过程： 首先将树轻重链剖分，在dfs的过程中先dfs轻儿子，再dfs重儿子。 假设某一个点的儿
Codeforces 600E Lomsat gelral(启发性合并/线段树合并)
m0_56280274的博客
03-19 442
题目链接：Lomsat gelral 题意：给定一棵以1为根的树，每个节点有一种颜色，求以每个节点为根的子树内出现次数最多的颜色编号和 题解：这题可以用线段树合并也可以用启发性合并做，我这里用的是启发性合并的做法，首先我们先找出每个点的重儿子（子树最多的儿子），因为只用了一个数组储存答案，所以每次都要清除更新过的点，防止干扰其他儿子的影响，我们可以每次处理时先遍历轻儿子，每次把轻儿子处理完后暴力清空其更新过的点，最后遍历重儿子(最后遍历的子树实际上可以不清空，因为回溯中也需要重新标记整颗树，保留重儿子可
Codeforces 600E （dsu on tree）
WayJasy的博客
11-07 158
传送门 题意： 求以iii为根的子树中，出现颜色次数最多的颜色编号之和。 思路： 先考虑最暴力的解法：枚举每个节点，dfs其子树暴力求解，复杂度O(n2)O(n^2)O(n2) 我们可以先重链剖分出每个节点的重儿子，处理轻链的答案然后合并到重儿子上，更新答案后消除轻儿子对答案的贡献，复杂度O(nlogn)O(nlogn)O(nlogn) #include<iostream> #incl...
codeforces600E. Lomsat gelral（dsu on tree笔记）
b19980703的博客
09-03 147
知识前驱：树链剖分 codeforces600E. Lomsat gelral 题意：给出一个树，求出每个节点的子树中出现次数最多的颜色的编号和 分析：递归求解，对于一棵树，求出他的所有子树的颜色编号次数加上它本身，找到最大即是它的答案。对于他的兄弟来说，应该将计数器清0并同过程求解，在最后一个兄弟计算完毕后，此时计数器可不清0，再次统计该兄弟的兄弟（即该兄弟的同深度其他节点），便...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值