Dominant Indices(CF 1009 F)

前言

记录一下长链剖分的小技巧

题目相关

链接

题目大意

一棵$n$个节点的树，定义$f_{i,j}$为与$i$号点距离为$j$的节点数量，对于每个$i$求出一个最小的$j$满足$f_{i,j}$是所有$j$的取值中最大的

数据范围

$n\le 10^6$

题解

直接长链剖分即可，我们发现“重”儿子继承的时候是直接最前面加个1，所以可$\mathcal{O}(1)$继承，“轻”儿子合并直接暴力，复杂度是$\mathcal{O}(len)$的（$len$为“轻”儿子所在长链的长度）
我们发现复杂度是sigma长链长度的，所以算法总复杂度为$\mathcal{O}(n)$

代码

实际实现的时候有些细节和技巧
这里贴一下代码中变量的解释
D[u].sz[i]表示当前点u子树内距离为len[u]-i-1的点的数量
然后D[u].maxx和D[u].pl分别代表最大值和最大值的位置
这样就能方便的合并了

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rg register
template <typename T> inline void read(T&x){char cu=getchar();x=0;bool fla=0;while(!isdigit(cu)){if(cu=='-')fla=1;cu=getchar();}while(isdigit(cu))x=x*10+cu-'0',cu=getchar();if(fla)x=-x;}
template <typename T> inline void printe(const T x){if(x>=10)printe(x/10);putchar(x%10+'0');}
template <typename T> inline void print(const T x){if(x<0)putchar('-'),printe(-x);else printe(x);}
template <typename T> inline T gcd(const T a,const T b){if(!b)return a;return gcd(b,a%b);}
template <typename T> inline T min(const T a,const T b){return a<b?a:b;}
const int maxn=1000001;
int n;
vector<int>E[maxn];
struct ANS
{
	vector<int>sz;
	int maxx,pl;
}D[maxn];
int tot;
int ans[maxn];
int son[maxn],len[maxn];
int res[maxn];
void dfs1(const int u,const int fa)
{
	for(unsigned int i=0;i<E[u].size();i++)
	{
		const int v=E[u][i];
		if(v!=fa)
		{
			dfs1(v,u);
			if(len[son[u]]<len[v])son[u]=v;
		}
	}
	len[u]=len[son[u]]+1;
}
void dfs2(const int u,const int fa)
{
	if(son[u])
	{
		dfs2(son[u],u);
		const int ID=ans[u]=ans[son[u]];
		for(unsigned int i=0;i<E[u].size();i++)
		{
			const int v=E[u][i];
			if(v!=fa&&v!=son[u])
			{
				dfs2(v,u);
				const int TO=ans[v];
				for(rg int j=0;j<len[v];j++)
				{
					const int P=len[u]-1-len[v]+j;
					D[ID].sz[P]+=D[TO].sz[j];
					if(D[ID].sz[P]>D[ID].maxx)D[ID].maxx=D[ID].sz[P],D[ID].pl=P;
					else if(D[ID].sz[P]==D[ID].maxx&&P>D[ID].pl)D[ID].pl=P;
				}
			}
		}
		D[ID].sz.push_back(1);
		if(D[ID].maxx==1)D[ID].pl=D[ID].sz.size()-1;
	}
	else
	{
		const int ID=ans[u]=++tot;
		D[ID].sz.push_back(1),D[ID].pl=0,D[ID].maxx=1;
	}
	res[u]=len[u]-D[ans[u]].pl-1;
}
int main()
{
	read(n);
	for(rg int i=1;i<n;i++)
	{
		int u,v;read(u),read(v);
		E[u].push_back(v),E[v].push_back(u); 
	}
	dfs1(1,0);
	dfs2(1,0);
	for(rg int i=1;i<=n;i++)print(res[i]),putchar('\n');
	return 0;
}

总结

很巧妙的一个算法，不需要log而且还好写