dsu on tree 模板 (树上启发式合并)

最新推荐文章于 2023-11-06 19:53:08 发布
最新推荐文章于 2023-11-06 19:53:08 发布
阅读量266 收藏
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xianqiuyigedao/article/details/123921192
版权

题目
题目
题意: T1:给定一棵n个点的树，求每个点以它为树根的子树的颜色种类。
T2:给定一棵n个点的树，求每个点以它为树根的子树的dominating color之和。
dominating color: 在本棵树中出现次数最多(或之一)
思路: dsu on tree，树上启发式合并，不过这个算法并没有用到dsu(并查集)。
考虑暴力求解，以每个点为起点dfs搜索一次，时间复杂度为n^2。
但是可以利用轻重链的性质，优化为nlogn。
  注意到一个点的贡献是所有儿子求和，求完和儿子的贡献就用不到了。可以拿一个儿子的数组作为基点(就像并查集定一个点)，其他点向他合并。那么自然找重儿子作为基点。（因为重儿子的定义是它对应子树的大小是所有儿子里最大的(或之一)，至少占半壁江山）
  而轻重链的性质决定了每个轻儿子到根节点的轻边个数不超过logn次。所以最多会被暴力合并logn次。轻儿子的子树大小<=父节点子树大小的一半，每有一条轻边都要/2，总共n个点，最多/logn次就到叶子了。
时间复杂度: O(nlogn)
代码:

// Problem: U41492 树上数颜色
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/U41492
// Memory Limit: 125 MB
// Time Limit: 1200 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<complex>
#include<cstring>
#include<cmath>
#include<vector>
#include<map>
#include<unordered_map>
#include<list>
#include<set>
#include<queue>
#include<stack>
#define OldTomato ios::sync_with_stdio(false),cin.tie(nullptr),cout.tie(nullptr)
#define fir(i,a,b) for(int i=a;i<=b;++i) 
#define mem(a,x) memset(a,x,sizeof(a))
#define p_ priority_queue
// round() 四舍五入 ceil() 向上取整 floor() 向下取整
// lower_bound(a.begin(),a.end(),tmp,greater<ll>()) 第一个小于等于的
// #define int long long //QAQ
using namespace std;
typedef complex<double> CP;
typedef pair<int,int> PII;
typedef long long ll;
// typedef __int128 it;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const ll inf = 1e18;
const int N = 2e5+10;
const int M = 1e6+10;
const int mod = 1e9+7;
const double eps = 1e-6;
inline int lowbit(int x){ return x&(-x);}
template<typename T>void write(T x)
{
    if(x<0)
    {
        putchar('-');
        x=-x;
    }
    if(x>9)
    {
        write(x/10);
    }
    putchar(x%10+'0');
}
template<typename T> void read(T &x)
{
    x = 0;char ch = getchar();ll f = 1;
    while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
    while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
int n,m,k,T;
int col[N];
int cnt[N]; //当前的颜色计数
int sum = 0; //维护当前有几种颜色
int son[N]; //重儿子
int sz[N]; //子树大小
int ans[N]; //以u为根的结果
int h[N],e[N<<1],ne[N<<1],idx = 0;
int Son; //维护当前的重儿子
void add2(int a,int b)
{
	e[idx] = b,ne[idx] = h[a],h[a] = idx++;
}
void dfs1(int cur,int fa)
{
	sz[cur] = 1;
    for(int i=h[cur];~i;i=ne[i])
    {
    	int j = e[i];
    	if(j == fa) continue;
    	dfs1(j,cur);
    	sz[cur] += sz[j];
    	if(sz[j] > sz[son[cur]]) son[cur] = j;
    }
}
void add(int cur,int fa,int val)
{
	int x = col[cur];
	if(val == 1)
	{
	   if(++cnt[x] == 1) sum++;
	} 
	else if(--cnt[x] == 0) sum--;
	for(int i=h[cur];~i;i=ne[i])
	{
		int j = e[i];
		if(j == fa) continue;
		if(j == Son) continue;
		add(j,cur,val);
	}
}
void dfs2(int cur,int fa,int opt)
{
	for(int i=h[cur];~i;i=ne[i])
	{
		int j = e[i];
		if(j == fa) continue;
		if(j != son[cur]) dfs2(j,cur,0);
	}
	if(son[cur]) dfs2(son[cur],cur,1),Son = son[cur];
	add(cur,fa,1); //合并
	Son = 0; //合并完，不用记录重儿子了
	ans[cur] = sum;
	if(!opt) add(cur,fa,-1),sum = 0; //删除轻儿子的贡献
}
void solve()
{
   mem(h,-1);
   read(n);
   for(int i=0;i<n-1;++i)
   {
   	  int x,y; read(x),read(y);
   	  add2(x,y),add2(y,x);
   }
   for(int i=1;i<=n;++i) read(col[i]);
   dfs1(1,0),dfs2(1,0,0);
   read(m);
   while(m--)
   {
   	  int x; read(x);
   	  printf("%d\n",ans[x]);
   }
}
signed main(void)
{  
   T = 1;
   // OldTomato; cin>>T;
   // read(T);
   while(T--)
   {
   	 solve();
   }
   return 0;
}


// Problem: E. Lomsat gelral
// Contest: Codeforces - Educational Codeforces Round 2
// URL: https://codeforces.com/contest/600/problem/E
// Memory Limit: 256 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<complex>
#include<cstring>
#include<cmath>
#include<vector>
#include<map>
#include<unordered_map>
#include<list>
#include<set>
#include<queue>
#include<stack>
#define OldTomato ios::sync_with_stdio(false),cin.tie(nullptr),cout.tie(nullptr)
#define fir(i,a,b) for(int i=a;i<=b;++i) 
#define mem(a,x) memset(a,x,sizeof(a))
#define p_ priority_queue
// round() 四舍五入 ceil() 向上取整 floor() 向下取整
// lower_bound(a.begin(),a.end(),tmp,greater<ll>()) 第一个小于等于的
// #define int long long //QAQ
using namespace std;
typedef complex<double> CP;
typedef pair<int,int> PII;
typedef long long ll;
// typedef __int128 it;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const ll inf = 1e18;
const int N = 2e5+10;
const int M = 1e6+10;
const int mod = 1e9+7;
const double eps = 1e-6;
inline int lowbit(int x){ return x&(-x);}
template<typename T>void write(T x)
{
    if(x<0)
    {
        putchar('-');
        x=-x;
    }
    if(x>9)
    {
        write(x/10);
    }
    putchar(x%10+'0');
}
template<typename T> void read(T &x)
{
    x = 0;char ch = getchar();ll f = 1;
    while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
    while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
int n,m,k,T;
int col[N];
ll ans[N];
ll sum; //当前重儿子的和
int sz[N];
int son[N]; //重儿子
int Son,mx; //当前的重儿子和最大值
int cnt[N]; //维护当前的颜色数量
int h[N],e[N<<1],ne[N<<1],idx = 0;
void add2(int a,int b)
{
	e[idx] = b,ne[idx] = h[a],h[a] = idx++;
}
inline void init()
{
    sum = 0;
    mx = 0;
}
void dfs1(int cur,int fa) //预处理重儿子
{
	sz[cur] = 1;
	for(int i=h[cur];~i;i=ne[i])
	{
		int j = e[i];
		if(j == fa) continue;
		dfs1(j,cur);
		sz[cur] += sz[j];
		if(sz[j] > sz[son[cur]]) son[cur] = j;
	}
}
void add(int cur,int fa,int val)
{
	cnt[col[cur]] += val;
	if(cnt[col[cur]] > mx) mx = cnt[col[cur]],sum = col[cur];
	else if(cnt[col[cur]] == mx) sum += col[cur];
	for(int i=h[cur];~i;i=ne[i])
	{
		int j = e[i];
		if(j == fa) continue;
		if(j == Son) continue;
		add(j,cur,val);
	}
}
void dfs2(int cur,int fa,int opt) //1:重儿子不清空数组，0:轻儿子清空数组
{
	for(int i=h[cur];~i;i=ne[i])
	{
		int j = e[i];
		if(j == fa) continue;
		if(j != son[cur]) dfs2(j,cur,0); //暴力求解轻儿子的贡献
	}
	if(son[cur]) dfs2(son[cur],cur,1),Son = son[cur];
	add(cur,fa,1),Son = 0; //暴力统计所有轻儿子的贡献，相当于将贡献合并到重儿子身上
	ans[cur] = sum;
	if(!opt) add(cur,fa,-1),init(); //删除轻儿子的贡献
}
void solve()
{
   read(n); mem(h,-1);
   for(int i=1;i<=n;++i) read(col[i]);
   for(int i=0;i<n-1;++i)
   {
   	   int x,y; read(x),read(y);
   	   add2(x,y),add2(y,x);
   }
   dfs1(1,0);
   dfs2(1,0,0);
   for(int i=1;i<=n;++i) printf("%lld ",ans[i]);
}
signed main(void)
{  
   T = 1;
   // OldTomato; cin>>T;
   // read(T);
   while(T--)
   {
   	 solve();
   }
   return 0;
}
想出成果的acmer
关注
专栏目录
[trick]dsu on tree
YveH
12-04 7853
学习笔记
dsu on tree(树上启发式合并)算法总结+习题
mumei的博客
02-03 2697
前几天补了一下在camp中没学到的算法，树上启发式合并，一个O(nlogn)处理树上查询问题比较好的算法（其实就是暴力） 前置知识 学习这个算法之前需要知道一些树链剖分中的概念，不知道也没问题，下面我会给出 节点的大小：以当前节点为根的子树中的节点个数 重儿子：所有儿子节点中大小最大的那个节点 轻儿子：除重儿子之外的儿子节点 至于节点的深度等常见概念就不解释了。 算法思想 先拿一...
[学习笔记]Dsu On Tree
weixin_34111790的博客
03-10 163
[dsu on tree]【学习笔记】 - Candy? - 博客园 题单： 也称：树上启发式合并 可以解决绝大部分不带修改的离线询问的子树查询问题 流程： 1.重链剖分找重儿子 2.sol:全局用桶或者数据结构存信息。　　①递归所有的轻儿子，回溯前删除贡献 　　②递归重儿子，不删除贡献 　　③暴力找所有轻儿子，加入贡献 　　④更新x的答案 　　⑤如果x是父亲...
dsu on tree模板
weixin_45772744的博客
04-12 410
dsu on tree解决某个子树的众数，种类数问题 时间复杂度 nlog2n #include <bits/stdc++.h> using namespace std; const int N=1e5+10; int h[N],to[2*N],ne[2*N],cnt; int sz[N],dep[N],fa[N],son[N]; int top[N],dfn,id[N],R[N],idx[N],skp; int num[N],col[N],sum,ans[N];//记录出现颜色种类.
dsu on tree
weixin_34366546的博客
12-25 67
osu on tree? dsu on tree! 这种操作可以在$O(nlogn)$的时间内解决一些无修改子树询问问题。 咱知道把一棵树轻重链剖分后，树的轻链，重链都只有$O(logn)$个。 这个算法就是利用了这一点，递归处理时保留重儿子的信息，轻儿子的则重新计算。 乍一看感觉很暴力，但是实际上是$O(nlogn)$的。 来看几道题吧。 CodeForces - 600E ...
Lomsat gelral(dsu on tree模板理解)
代码笔记本
11-13 316
https://www.luogu.com.cn/problem/CF600E 题意翻译 有一棵nn个结点的以11号结点为根的有根树。 每个结点都有一个颜色，颜色是以编号表示的，ii号结点的颜色编号为c_ici​。 如果一种颜色在以xx为根的子树内出现次数最多，称其在以xx为根的子树中占主导地位。显然，同一子树中可能有多种颜色占主导地位。 你的任务是对于每一个i\in[1,n]i∈[1,n]，求出以ii为根的子树中，占主导地位的颜色的编号和。 n\le 10^5,c_...
树上启发式合并（DSU on Tree）
KaiserWilheim的博客
12-17 634
一种在 O(nlogn) 复杂度内求树上问题的算法。
启发式合并（dsu），树上启发式合并（dsu on tree）总结
最新发布
x052xiao的博客
11-06 349
启发式合并（dsu），树上启发式合并（dsu on tree）总结
树上启发式合并（dsu on tree）
UniverseofHK的博客
01-01 455
Lomsat gelral 之前没有记录过dsu on tree，挑了一个板子题记录一下 DSU on tree（Disjoint Set Union，树上启发式合并） 思想：利用每个节点到根节点路径上的轻边数复杂度是logloglog级别的，同时只有当每次遍历轻边时才会将整棵轻边连接的子树额外暴力遍历一遍，所以每个节点被暴力遍历的次数就是logloglog级别的，这样就保证了整体复杂度在log...
树上启发式合并
矮纸斜行闲作草
09-29 2120
树上启发式合并算法原理+流程+复杂度 又称dsu on tree,但这个算法和并查集没啥联系，可能借鉴了按秩合并的思想吧。 算法原理+流程+复杂度 参考大佬博客传送 我们先从第一个例题开始看起： E. Lomsat gelral 题意是给定了一个无根树，带点权，q次询问，每次询问某棵子树内，点权众数之和。（如果2 3 4都是众数，那么答案是2+3+4=9) ...
DSU模板(树的启发式合并)
weixin_30432007的博客
03-27 186
摘自Codeforces博客 With dsu on tree we can answer queries of this type: How many vertices in subtree of vertexvhas some property in O(n lg n) time (for all of the queries). For example: Given a tree...
DSU模板题（树上并查集）
ryeblablabla的博客
03-31 341
众所周知，苏大的校园非常大，对于peter来说，有的时候需要从本部到东区上课真是十分头疼的一件事！而peter沉迷打cf(cross fire)，常常晚上两点才睡觉，所以他早上总是起得很晚。 又是一天早八时间！peter又要赶去上课了。 peter想知道，从自己的宿舍到上课的教学楼需要的最短距离是多少，请聪明的你帮他算算吧。 苏大的校园是一个 n×mn\times mn×m 大小的矩形，上面的每一个单元格由一个数字 aija_{ij}aij​ 表示，有以下三种含义： 如果为−1-1−1，表示这个地方是草坪
dsu_on_tree
blue_kid的博客
08-29 355
大佬博客：https://codeforces.com/blog/entry/44351 使用范围：常用来求子树的信息，比如，如果一棵树上每个节点都有一种颜色，求一个子树中颜色c的出现次数 复杂度分析：这个就是启发式合并，每一次合并都将小的集合合并到大的集合，每个元素的合并次数最多为lognlognlogn次，看起来像是n2n2n^2的合并，实际复杂度只有nlognnlognnlogn，如果使...
DSU on tree
xmr_pursue_dreams的博客
11-13 255
DSU on tree DSU on tree，是可以求解一些特殊的离线的树上问题的方法，是一种类似于链剖分的思想——每次求解完某一子树的信息之后，保留并继承其重儿子的答案，清空轻儿子的贡献，再继续向上合并下去。 An Example：CF600E Lomsat gelral 简要题意： 一棵树有n个结点，每个结点都是一种颜色，每个颜色有一个编号，求树中每个子树的最多的颜色编号的和...
DSU ON TREE
weixin_43918350的博客
03-06 177
Strange Memory 原题地址 当时比赛的时候，在观战席看出来了应该要用启发式合并，后来自己敲的时候想当然地使用了STL。由于不仅要记录结点的值，还要记录结点的id，所以必须定义一个结构体，但是重载结构体<时出现了许多问题。首先是set.insert()不了，后来查了博客发现重载函数必须写成这样 bool operator <(const nod& u)const { return a < u.a; } 才能insert()进去，而且set的迭代器无法直接相减（set内
Dsu on tree
OZY的博客
11-02 643
Dsu on tree
使用DSU存储库在DELL服务器上安装和配置OMSA
"这篇文档介绍了如何在DELL服务器上使用DSU(Dell System Update)存储库来安装并配置OMSA(Open Manage Server Administrator)，从而实现远程管理和监控服务器的硬盘及RAID配置。" DELL服务器的OMSA(OpenManage ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值