世界树

题面

题意

给出一棵树,每次给出其中一些点成为控制点,每个点被距离它最近的控制点控制(若到多个控制点的距离相等则视为被编号最小的控制点控制),输出每个控制点控制了几个点.

做法

因为每次询问书树上的一些点,因此不难想到用虚树.
树上的点可以说有以下几类:
1.不属于虚树的根节点的子树的点,用n-size[root]即可求出
2.被压缩在虚树的边上的点或者属于一棵根节点被压缩在虚树的边上但不包含虚树上的点的子树.
3.属于虚树的根节点的子树的点但不属于2的点,可以对虚树上的点都扫一遍,用虚树上的点的子树大小减去所有子树含有虚树上的点的儿子节点的子树大小可以求出
因此难点在于求2中的点.
用dp的方法,两次dfs求出虚树上的每个节点被那个节点控制和它到控制点的距离,然后难点就在于一条虚树上的边上的点分别属于边的两端点的控制点.
对于这种边,用倍增找到分界点,然后分别计算两边的点的贡献即可.

实现起来的细节还是很多的!

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stack>
#include<vector>
#include<cmath>
#define INF 0x3f3f3f3f
#define N 300100
using namespace std;

int n,m,bb,first[N],deep[N],dfn[N],tt,num[N],top[N],fa[N][20],rt,d[N],bk[N],dis[N],ans[N],xl[N],sz[N];
struct Bn
{
    int to,next;
} bn[N<<1];
stack<int>sta;
vector<int>xb[N],dn;

inline int ask_pos(int now,int bs)
{
    int i,j,qw=deep[now]-bs;
    for(i=19; i>=0; i--)
    {
        if(deep[fa[now][i]]<qw) continue;
        if(deep[fa[now][i]]==qw) return fa[now][i];
        now=fa[now][i];
    }
    return now;
}

inline int ask_size(int now,int bs)
{
    return sz[ask_pos(now,bs)]-sz[now];
}

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

inline void ad(int u,int v)
{
    if(!u||!v) return;
    xb[u].push_back(v);
    d[v]=deep[v]-deep[u];
}

int ft(int u)
{
    return top[u]==u?u:top[u]=ft(top[u]);
}

int get(int now,int last)
{
    int p,q,mm=0,mx=0,tmp,res=1;
    dfn[now]=++tt;
    for(p=first[now]; p!=-1; p=bn[p].next)
    {
        if(bn[p].to==last) continue;
        deep[bn[p].to]=deep[now]+1;
        fa[bn[p].to][0]=now;
        tmp=get(bn[p].to,now);
        res+=tmp;
        if(tmp>mx)
        {
            mx=tmp;
            mm=bn[p].to;
        }
    }
    if(mm) top[mm]=now;
    return sz[now]=res;
}

inline bool cmp(int u,int v)
{
    return dfn[u]<dfn[v];
}

inline int lca(int u,int v)
{
    if(!u||!v) return 0;
    for(; ft(u)!=ft(v);)
    {
        if(deep[ft(u)]<deep[ft(v)]) swap(u,v);
        u=fa[ft(u)][0];
    }
    return deep[u]<deep[v]?u:v;
}

inline void build(int u)
{
    int i,j,p,q,l;
    sta.push(0);
    for(i=1; i<=u; i++)
    {
        l=lca(sta.top(),num[i]);
        for(p=0; deep[l]<deep[sta.top()];)
        {
            ad(sta.top(),p);
            p=sta.top();
            sta.pop();
        }
        if(l!=sta.top()) sta.push(l),dn.push_back(l);
        ad(sta.top(),p);
        sta.push(num[i]);
        dn.push_back(num[i]);
    }
    for(p=sta.top(),sta.pop(); !sta.empty();)
    {
        ad(sta.top(),p);
        p=sta.top();
        sta.pop();
    }
    for(i=0,p=N; i<dn.size(); i++)
    {
        if(deep[dn[i]]<p)
        {
            p=deep[dn[i]];
            rt=dn[i];
        }
    }
}

void df(int now)
{
    int i,j,tmp;
    for(i=0; i<xb[now].size(); i++)
    {
        tmp=xb[now][i];
        df(tmp);
        if(dis[tmp]+d[tmp]<dis[now]||(dis[tmp]+d[tmp]==dis[now]&&bk[tmp]<bk[now]))
        {
            bk[now]=bk[tmp];
            dis[now]=dis[tmp]+d[tmp];
        }
    }
}

void dfs(int now)
{
    int i,j,tmp;
    for(i=0; i<xb[now].size(); i++)
    {
        tmp=xb[now][i];
        if(dis[tmp]>dis[now]+d[tmp]||(dis[tmp]==dis[now]+d[tmp]&&bk[now]<bk[tmp]))
        {
            bk[tmp]=bk[now];
            dis[tmp]=dis[now]+d[tmp];
        }
        dfs(tmp);
    }
}

void Dfs(int now)
{
    int i,j,tmp,k,t;
    for(i=0; i<xb[now].size(); i++)
    {
        tmp=xb[now][i];
        if(bk[now]==bk[tmp]) ans[bk[now]]+=ask_size(tmp,d[tmp]-1);
        else
        {
            if(d[tmp]-1>abs(dis[now]-dis[tmp]))
            {
                t=0;
                if(dis[now]>dis[tmp])
                {
                    t+=dis[now]-dis[tmp];
                }
                k=d[tmp]-abs(dis[now]-dis[tmp])-1;
                t+=k/2;
                if(k%2&&bk[tmp]<bk[now]) t++;
            }
            else
            {
                if(dis[now]<dis[tmp]) t=0;
                else t=d[tmp]-1;
            }
            ans[bk[tmp]]+=ask_size(tmp,t);
            ans[bk[now]]+=ask_size(ask_pos(tmp,t),d[tmp]-t-1);
        }
        Dfs(tmp);
    }
}

inline void init()
{
    int i,j;
    for(i=1; i<20; i++)
    {
        for(j=1; j<=n; j++)
        {
            fa[j][i]=fa[fa[j][i-1]][i-1];
        }
    }
}

int main()
{
    memset(first,-1,sizeof(first));
    int i,j,k,p,q;
    cin>>n;
    for(i=1; i<n; i++)
    {
        scanf("%d%d",&p,&q);
        add(p,q),add(q,p);
    }
    for(i=1; i<=n; i++)
        top[i]=i;
    deep[1]=1;
    get(1,-1);
    init();
    cin>>m;
    for(i=1; i<=m; i++)
    {
        scanf("%d",&p);
        for(j=1; j<=p; j++)
        {
            scanf("%d",&num[j]);
            xl[j]=num[j];
        }
        sort(num+1,num+p+1,cmp);
        build(p);
        for(j=0; j<dn.size(); j++)
        {
            bk[dn[j]]=dis[dn[j]]=INF;
        }
        for(j=1; j<=p; j++) bk[num[j]]=num[j],dis[num[j]]=0;
        df(rt);
        dfs(rt);
        Dfs(rt);
        ans[bk[rt]]+=n-sz[rt];
        for(j=0; j<dn.size(); j++)
        {
            q=0;
            for(k=0; k<xb[dn[j]].size(); k++)
            {
                q+=sz[ask_pos(xb[dn[j]][k],deep[xb[dn[j]][k]]-deep[dn[j]]-1)];
            }
            ans[bk[dn[j]]]+=sz[dn[j]]-q;
        }
        for(j=1; j<=p; j++)
        {
            printf("%d ",ans[xl[j]]);
            ans[xl[j]]=0;
        }
        puts("");
        for(j=0; j<dn.size(); j++) xb[dn[j]].clear();
        dn.clear();
    }
}