DSU on tree

DSU on tree

DSU on tree，是可以求解一些特殊的离线的树上问题的方法，是一种类似于链剖分的思想——每次求解完某一子树的信息之后，保留并继承其重儿子的答案，清空轻儿子的贡献，再继续向上合并下去。

An Example：CF600E Lomsat gelral

 

简要题意：

一棵树有n个结点，每个结点都是一种颜色，每个颜色有一个编号，求树中每个子树的最多的颜色编号的和。

其中 n<=1e5。

这是一道最基本的DSU on tree的题。

我们想要求出一颗子树的答案，就要知道每一个颜色的出现次数   ，如果我们能够从子树中获得的信息，并加上这一个节点颜色的贡献，就能够统计答案。

但单纯地这样求解答案显然是不行的，因为颜色数量有个，总的时空复杂度都是的。

此时，我们可以应用上述DSU on tree的思想，只继承重儿子的，清空轻儿子的，因此我们只需要开一个数组，统计每一个颜色的出现次数。

统计答案时，继承重儿子的，暴力统计所有轻子树的。倘若当前子树是轻儿子，清空，否则保留。

时间复杂度为    ，空间复杂度 。

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <cassert>
#include <string.h>
//#include <unordered_set>
//#include <unordered_map>
//#include <bits/stdc++.h>

#define MP(A,B) make_pair(A,B)
#define PB(A) push_back(A)
#define SIZE(A) ((int)A.size())
#define LEN(A) ((int)A.length())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define fi first
#define se second

using namespace std;

template<typename T>inline bool upmin(T &x,T y) { return y<x?x=y,1:0; }
template<typename T>inline bool upmax(T &x,T y) { return x<y?x=y,1:0; }

typedef long long ll;
typedef unsigned long long ull;
typedef long double lod;
typedef pair<int,int> PR;
typedef vector<int> VI;

const lod eps=1e-11;
const lod pi=acos(-1);
const int oo=1<<30;
const ll loo=1ll<<62;
const int mods=1e9+7;
const int MAXN=1000005;
const int INF=0x3f3f3f3f;//1061109567
/*--------------------------------------------------------------------*/
inline int read()
{
	int f=1,x=0; char c=getchar();
	while (c<'0'||c>'9') { if (c=='-') f=-1; c=getchar(); }
	while (c>='0'&&c<='9') { x=(x<<3)+(x<<1)+(c^48); c=getchar(); }
	return x*f;
}
vector<int> e[MAXN];
int col[MAXN],cnt[MAXN],dfn[MAXN],sz[MAXN],id[MAXN],mx[MAXN],f[MAXN],DFN=0,num=0;
ll Ans[MAXN],sum=0;
void dfs1(int x,int father)
{
	dfn[x]=++DFN,id[DFN]=x,sz[x]=1,mx[x]=-1;
	for (auto v:e[x])
	{
		if (v==father) continue;
		dfs1(v,x);
		sz[x]+=sz[v];
		if (mx[x]==-1||sz[v]>sz[mx[x]]) mx[x]=v;
	}
	f[x]=DFN;
}
void modify(int x,int father,int c,int heavy_son)
{
	cnt[col[x]]+=c;
	if (cnt[col[x]]>num) num=cnt[col[x]],sum=col[x];
	else if (cnt[col[x]]==num) sum+=col[x];
	for (auto v:e[x])
	{
		if (v==father||v==heavy_son) continue;
		modify(v,x,c,heavy_son);
	}
}
void dfs2(int x,int father,int flag)
{
	for (auto v:e[x])
	{
		if (v==father||v==mx[x]) continue;
		dfs2(v,x,0);
	}
	if (mx[x]!=-1) dfs2(mx[x],x,1);
	modify(x,father,1,mx[x]);
	Ans[x]=sum;
	if (!flag) modify(x,father,-1,-1),sum=num=0;
}
int main()
{
	int n=read();
	for (int i=1;i<=n;i++) col[i]=read();
	for (int i=1;i<n;i++)
	{
		int u=read(),v=read();
		e[u].PB(v);
		e[v].PB(u);
	}
	dfs1(1,0);
	dfs2(1,0,0);
	for (int i=1;i<=n;i++) printf("%lld ",Ans[i]);
	return 0;
}

一点总结

DSU on tree是一种巧妙的思想，其精妙之处在于保留重子树的贡献，去除重子树产生的时间，从而保证时间复杂度的正确，且实现很简单，只需要几个暴力拼凑在一起，应用广泛。