CodeForces - 686D D. Kay and Snowflake

题面

题意

给出一棵树,多次询问以某个节点为根的子树的重心.

法一 倍增

易知一棵树的重心满足整棵树减去重心的子树大小小于等于整棵树大小的一半,而且重心的最大子节点的子树大小也小于等于整棵树大小的一半.
因此可以用倍增维护某个点的第2^i个最大子孙节点(沿着子树最大的子节点找下去),不断比较大小,复杂度O(n*logn).

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<ctime>
#define C ch=getchar()
#define N 300100
using namespace std;

int n,m,bb,first[N],size[N],ans[N],mm[N][20],mx[N][20];
struct Bn
{
    int to,next;
}bn[N*2];

inline void add(int u,int v)
{
    bb++;
    bn[bb].to=v;
    bn[bb].next=first[u];
    first[u]=bb;
}

inline int ask(int now,int siz,int bs)
{
    if(!bs)
    {
        if((size[mm[now][0]]<<1)<=siz&&(size[now]<<1)>=siz) return now;
        return mm[now][0];
    }
    int i;
    for(i=bs;i>=1;i--)
    {
        if(!mx[now][i]) continue;
        if((mx[now][i]<<1)<=siz&&(size[mm[now][i]]<<1)>=siz) return mm[now][i];
        if((mx[now][i]<<1)>=siz) return ask(mm[now][i],siz,i-1);
    }
    if((size[mm[now][0]]<<1)<=siz&&(size[now]<<1)>=siz) return now;
    return mm[now][0];
}

int dfs(int now,int last)
{
    int p,q,res=1;
    mx[now][0]=0,mm[now][0]=0;
    for(p=first[now];p!=-1;p=bn[p].next)
    {
        if(bn[p].to==last) continue;
        q=dfs(bn[p].to,now);
        res+=q;
        if(q>mx[now][0])
        {
            mx[now][0]=q;
            mm[now][0]=bn[p].to;
        }
    }
    if((mx[now][0]<<1)<=res)
        ans[now]=now;
    return size[now]=res;
}

inline int read()
{
    char C;
    int res=0;
    for(;ch<'0';C);
    for(;ch>='0';res=res*10+ch-48,C);
    return res;
}

int main()
{
//  freopen("1.txt","r",stdin);
//  freopen("2.txt","w",stdout);
    memset(first,-1,sizeof(first));
    register int i,j,p;
    n=read(),m=read();
    for(i=2;i<=n;i++)
    {
        p=read();
        add(p,i);
        add(i,p);
    }
    dfs(1,-1);
    for(i=1;(1 << i)<=n;i++)
    {
        for(j=1;j<=n;j++)
        {
            mm[j][i]=mm[mm[j][i-1]][i-1];
            if(!mm[j][i]) continue;
            mx[j][i]=mx[mm[j][i-1]][i-1];
        }
    }
    for(i=1;i<=n;i++)
    {
        if(!ans[i]) ans[i]=ask(i,size[i],19);
    }
    for(i=1;i<=m;i++)
    {
        p=read();
        printf("%d\n",ans[p]);
    }
}

但是实现起来细节较多,而且时间空间均很紧张,故推荐法二

法二

我们知道一棵树的重心一定在它的根上或是在它的子树最大的子节点所在子树内,且一定在该子树的重心或其上方.
因此我们可以从下往上找,重心默认为它自己,若存在一个子节点的子树大小大于其一半,就将重心改为这个子节点的重心,并不断向上跳,直到满足重心,因为每条边最多被跳一次,所以复杂度仍然为O(n),不仅好写,而且时间空间均十分优越.

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#define N 300100
using namespace std;

int bb,n,m,fa[N],size[N],ans[N],first[N];
struct Bn
{
    int to,next;
}bn[N];

inline void add(int u,int v)
{
    bb++;
    bn[bb].to=v;
    bn[bb].next=first[u];
    first[u]=bb;
}

void dfs(register int now)
{
    register int p,q;
    size[now]=1;
    ans[now]=now;
    for(p=first[now];p!=-1;p=bn[p].next)
    {
        dfs(bn[p].to);
        size[now]+=size[bn[p].to];
    }
    for(p=first[now];p!=-1;p=bn[p].next)
    {
        if(( size[bn[p].to]<<1 )>size[now])
        {
            ans[now]=ans[bn[p].to];
            break;
        }
    }
    for(;((size[now]-size[ans[now]])<<1)>size[now];ans[now]=fa[ans[now]]);
}

int main()
{
    memset(first,-1,sizeof(first));
    int i,p;
    cin>>n>>m;
    for(i=2;i<=n;i++)
    {
        scanf("%d",&fa[i]);
        add(fa[i],i);
    }
    dfs(1);
    for(i=1;i<=m;i++)
    {
        scanf("%d",&p);
        printf("%d\n",ans[p]);
    }
}