Codeforces 1009 F. Dominant Indices(长链剖分/树上启发式合并）

F. Dominant Indices



题意：

给一颗无向树，根为1。对于每个节点，求其子树中，哪个距离下的节点数量最多。数量相同时，取较小的那个距离。

题目：

这类题一般的做法是树上的启发式合并，复杂度是O(nlogn)。但由于这题所求的信息与深度有关，因此可以使用长链剖分的技巧，复杂度可以是O（n）。

长链剖分可以维护以深度为下标的信息。先预处理，以深度为依据，标记长儿子。维护答案时，对于每个节点，O（1）继承其长儿子的信息。然后暴力合并其他儿子。则时间复杂度是所有长链的长度之和，即O（n）。对于空间而言，可以通过维护一根指针来合理分配空间，使得所用空间也是线性的。

代码：

#include<bits/stdc++.h>
#define dd(x) cout<<#x<<" = "<<x<<" "
#define de(x) cout<<#x<<" = "<<x<<"\n"
#define sz(x) int(x.size())
#define All(x) x.begin(),x.end()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> P;
typedef priority_queue<int> BQ;
typedef priority_queue<int,vector<int>,greater<int> > SQ;
const int maxn=1e6+10,mod=1e9+7,INF=0x3f3f3f3f;
vector<int> G[maxn];
int deep[maxn],maxd[maxn],son[maxn],ans[maxn];
void dfs1(int fa,int u)
{
	deep[u]=maxd[u]=deep[fa]+1;
	for (auto& v:G[u])
	{
		if (v==fa)
			continue;
		dfs1(u,v);
		if (maxd[v]>maxd[u])
			maxd[u]=maxd[v],son[u]=v;
	}
}
int tmp[maxn],*p=tmp,*sum[maxn];
void dfs2(int fa,int u)
{
	sum[u][0]=1;
	if (son[u])
	{
		sum[son[u]]=sum[u]+1;
		dfs2(u,son[u]);
		ans[u]=ans[son[u]]+1;
	}
	for (auto& v:G[u])
	{
		if (v==fa||v==son[u])
			continue;
		sum[v]=p;
		p+=maxd[v]-deep[v]+1;
		dfs2(u,v);
		for (int i=0;i<=maxd[v]-deep[v];++i)
		{
			sum[u][i+1]+=sum[v][i];
			if ((sum[u][i+1]>sum[u][ans[u]])||(sum[u][i+1]==sum[u][ans[u]]&&i+1<ans[u]))
				ans[u]=i+1;
		}
	}
	if (sum[u][ans[u]]==1)
		ans[u]=0;
}
int main()
{
	int n;
	cin>>n;
	for (int i=1;i<n;++i)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		G[u].pb(v);
		G[v].pb(u);
	}
	dfs1(0,1);
	sum[1]=p;
	p+=maxd[1];
	dfs2(0,1);
	for (int i=1;i<=n;++i)
		printf("%d\n",ans[i]);
	return 0;
}