前言
记录一下长链剖分的小技巧
题目相关
题目大意
一棵 n n n个节点的树,定义 f i , j f_{i,j} fi,j为与 i i i号点距离为 j j j的节点数量,对于每个 i i i求出一个最小的 j j j满足 f i , j f_{i,j} fi,j是所有 j j j的取值中最大的
数据范围
n ≤ 1 0 6 n\le10^6 n≤106
题解
直接长链剖分即可,我们发现“重”儿子继承的时候是直接最前面加个1,所以可
O
(
1
)
\mathcal O(1)
O(1)继承,“轻”儿子合并直接暴力,复杂度是
O
(
l
e
n
)
\mathcal O(len)
O(len)的(
l
e
n
len
len为“轻”儿子所在长链的长度)
我们发现复杂度是sigma长链长度的,所以算法总复杂度为
O
(
n
)
\mathcal O(n)
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而且还好写