You are given a rooted undirected tree consisting of n vertices. Vertex 1 is the root.
Let’s denote a depth array of vertex x as an infinite sequence [dx,0,dx,1,dx,2,…], where dx,i is the number of vertices y such that both conditions hold:
x is an ancestor of y;
the simple path from x to y traverses exactly i edges.
The dominant index of a depth array of vertex x (or, shortly, the dominant index of vertex x) is an index j such that:
for every k<j, dx,k<dx,j;
for every k>j, dx,k≤dx,j.
For every vertex in the tree calculate its dominant index.
Input
The first line contains one integer n (1≤n≤106) — the number of vertices in a tree.
Then n−1 lines follow, each containing two integers x and y (1≤x,y≤n, x≠y). This line denotes an edge of the tree.
It is guaranteed that these edges form a tree.
Output
Output n numbers. i-th number should be equal to the dominant index of vertex i.
Examples
Input
4
1 2
2 3
3 4
Output
0
0
0
0
Input
4
1 2
1 3
1 4
Output
1
0
0
0
Input
4
1 2
2 3
2 4
Output
2
1
0
0
题意变化一下就是找到每个结点子树中同一深度最多的那个深度,相同时取最近的,用map记录每个结点子树结点在每个深度下的数量,用两个数组分别记录深度最多的结点数量和最近深度用来更新。
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+5;
int rt[N],dep[N];
int ma[N],num[N];
int ans[N];
vector<int> edge[N];
map<int,int> m[N];
map<int,int>::iterator it;
int merge(int x,int y)
{
if(m[x].size()<m[y].size())
swap(x,y);
for(it=m[y].begin();it!=m[y].end();it++)
{
m[x][it->first]+=it->second;
if(m[x][it->first]>num[x]||(m[x][it->first]==num[x]&&(it->first)<=ma[x]))
{
num[x]=m[x][it->first];
ma[x]=it->first;
}
}
return x;
}
void dfs(int x,int fa)
{
dep[x]=dep[fa]+1;
ma[rt[x]]=dep[x];
num[rt[x]]=1;
m[rt[x]][dep[x]]++;
for(int i=0;i<edge[x].size();i++)
if(edge[x][i]!=fa)
dfs(edge[x][i],x);
for(int i=0;i<edge[x].size();i++)
{
if(edge[x][i]!=fa)
rt[x]=merge(rt[x],rt[edge[x][i]]);
}
ans[x]=ma[rt[x]];
}
int n,a,b;
int main()
{
scanf("%d",&n);
dep[0]=0;
for(int i=1;i<n;i++)
{
scanf("%d%d",&a,&b);
edge[a].push_back(b);
edge[b].push_back(a);
rt[i]=i;
}
rt[n]=n;
dfs(1,0);
for(int i=1;i<=n;i++)
printf("%d\n",ans[i]-dep[i]);
}