BZOJ3572.【HNOI2014】世界树(worldtree)

Description

世界树是一棵无比巨大的树，它伸出的枝干构成了整个世界。在这里，生存着各种各样的种族和生灵，他们共同信奉着绝对公正公平的女神艾莉森，在他们的信条里，公平是使世界树能够生生不息、持续运转的根本基石。
世界树的形态可以用一个数学模型来描述：世界树中有n个种族，种族的编号分别从1到n，分别生活在编号为1到n的聚居地上，种族的编号与其聚居地的编号相同。有的聚居地之间有双向的道路相连，道路的长度为1。保证连接的方式会形成一棵树结构，即所有的聚居地之间可以互相到达，并且不会出现环。定义两个聚居地之间的距离为连接他们的道路的长度；例如，若聚居地a和b之间有道路，b和c之间有道路，因为每条道路长度为1而且又不可能出现环，所卧a与c之间的距离为2。
出于对公平的考虑，第i年，世界树的国王需要授权m[i]个种族的聚居地为临时议事处。对于某个种族x（x为种族的编号），如果距离该种族最近的临时议事处为y（y为议事处所在聚居地的编号），则种族x将接受y议事处的管辖（如果有多个临时议事处到该聚居地的距离一样，则y为其中编号最小的临时议事处）。
现在国王想知道，在q年的时间里，每一年完成授权后，当年每个临时议事处将会管理多少个种族（议事处所在的聚居地也将接受该议事处管理）。 现在这个任务交给了以智慧著称的灵长类的你：程序猿。请帮国王完成这个任务吧。

Input

第一行为一个正整数n，表示世界树中种族的个数。
接下来n-l行，每行两个正整数x，y，表示x聚居地与y聚居地之间有一条长度为1的双向道路。接下来一行为一个正整数q，表示国王询问的年数。
接下来q块，每块两行：
第i块的第一行为1个正整数m[i]，表示第i年授权的临时议事处的个数。
第i块的第二行为m[i]个正整数h[l]、h[2]、…、h[m[i]]，表示被授权为临时议事处的聚居地编号（保证互不相同）。

Output

输出包含q行，第i行为m[i]个整数，该行的第j(j=1，2…，，m[i])个数表示第i年被授权的聚居地h[j]的临时议事处管理的种族个数。

题目大意

给出树上的一些关键点，
求有几个点到关键点最短。

题解

虽然树的节点有很多，但是每次询问给出的关键点都不是很多。
有一个很显然的性质：如果某个点被关键点管辖，而且它的子树里面都没有关键点，那么它的子树的所有点都被这个关键点管辖。
所以统计每个关键点的管辖数的时候有很多点都是不需要直接访问的。

具体做法：
1、先构建出一棵虚树，保留所有关键点，以及它们的lca，
这样可以保留所有关键点在原树上的祖先关系。
边权即为原树上面点的个数。
2、通过两次遍历，得到虚树上面每一个点到它最近的关键点以及距离。
3、统计虚树上面每一条边的贡献。
分两种情况：
a.如果这条边的两个端点同时属于一个关键点管辖，显然这条边上的所有点，以及它们延伸出去的那些点也一定被这个关键点管辖。
b.管辖这条边两个端点的关键点不同，这个时候就比较麻烦了。
先找出两个关键点的管辖分界，即距离的一半。注意特殊判断距离刚刚好的时候选择编号较小的一个。
最后再分别统计这条边上半部分和下半部分对关键点的贡献。

code

#include<queue>
#include<cstdio>
#include<iostream>
#include<algorithm>
#include <cstring>
#include <string.h>
#include <cmath>
#include <math.h>
#include <time.h>
#define ll long long
#define N 3000003
#define M 103
#define db double
#define P putchar
#define G getchar
#define inf 998244353
using namespace std;
char ch;
void read(int &n)
{
    n=0;
    ch=G();
    while((ch<'0' || ch>'9') && ch!='-')ch=G();
    ll w=1;
    if(ch=='-')w=-1,ch=G();
    while('0'<=ch && ch<='9')n=(n<<3)+(n<<1)+ch-'0',ch=G();
    n*=w;
}

int max(int a,int b){return a>b?a:b;}
int min(int a,int b){return a<b?a:b;}
ll abs(ll x){return x<0?-x:x;}
ll sqr(ll x){return x*x;}
void write(ll x){if(x>9) write(x/10);P(x%10+'0');}

struct node
{
    int dis,bel;
}g[N],T;

bool operator < (node a,node b)
{
    return a.dis<b.dis || (a.dis==b.dis && a.bel<b.bel);
}

int n,Q,m,x,y,p[N];
int nxt[N*2],to[N*2],lst[N*2],tot,cru[N];
int f[19][N],size[N],dep[N],dfn[N],tt,le[N],ans[N];
int _z[20],z[N],top;
int fa[N],v[N],tr[N],q[N],S,L;

bool cmpdfn(int a,int b)
{
    return dfn[a]<dfn[b];
}

void ins(int x,int y)
{
    nxt[++tot]=lst[x];
    to[tot]=y;
    lst[x]=tot;
}

void ins_(int x,int y)
{
    fa[y]=x;v[y]=dep[y]-dep[x];
}

void dfs()
{
    z[top=1]=1;
    int x,i;
    memcpy(cru,lst,sizeof(cru));
    while(top)
    {
        x=z[top];
        if(!dfn[x])dfn[x]=++tt;
        i=lst[x];
        if(i==0)
        {
            top--;
            continue;
        }
        if(to[i]!=f[0][x])dep[to[i]]=dep[x]+1,f[0][to[i]]=x,z[++top]=to[i];
        lst[x]=nxt[i];
    }
    for(int i=1;i<=n;i++)
        q[i]=i;
    sort(q+1,q+1+n,cmpdfn);
    for(int i=n;i;i--)
        for(int j=cru[q[i]];j;j=nxt[j])
            if(to[j]!=f[0][q[i]])size[q[i]]+=size[to[j]];
}

int lca(int x,int y)
{
    if(dep[x]<dep[y])swap(x,y);
    for(int j=18;j>=0;j--)
        if(dep[f[j][x]]>=dep[y])x=f[j][x];
    if(x==y)return x;
    for(int j=18;j>=0;j--) 
        if(f[j][x]!=f[j][y])x=f[j][x],y=f[j][y];
    return f[0][x];
}

void build()
{
    for(int i=1;i<=m;i++)
        q[i]=tr[i]=p[i],g[p[i]].dis=0,g[p[i]].bel=p[i];
    S=m;
    sort(q+1,q+1+m,cmpdfn);

    top=0;
    for(int i=1;i<=m;i++)
    {
        if(top==0)
        {
            z[top=1]=q[i];
            continue;
        }
        L=lca(z[top],q[i]);
        while(dfn[z[top]]>dfn[L])
        {
            if(dfn[z[top-1]]<=dfn[L])
            {
                ins_(L,z[top--]);
                if(L!=z[top])z[++top]=L,tr[++S]=L,g[L].dis=inf;
                break;
            }
            else ins_(z[top-1],z[top]),top--;
        }
        z[++top]=q[i];
    }

    while(top>1)ins_(z[top-1],z[top]),top--;
}

void getG()
{
    sort(tr+1,tr+1+S,cmpdfn);
    int x,f;

    for(int i=S;i>1;i--)
    {
        x=tr[i],f=fa[x];
        T.dis=g[x].dis+v[x],T.bel=g[x].bel;
        if(T<g[f])g[f]=T;
    }

    for(int i=2;i<=S;i++)
    {
        x=tr[i],f=fa[x];
        T.dis=g[f].dis+v[x],T.bel=g[f].bel;
        if(T<g[x])g[x]=T;
    }
}

int find(int x,int t)
{
    int s=dep[x]-t;
    for(int i=18;i>=0;i--)
        if(_z[i]&s)x=f[i][x];
    return x;
}

void calc()
{
    memset(ans,0,sizeof(ans));
    for(int i=1;i<=S;i++)
        le[tr[i]]=size[tr[i]];

    ans[g[tr[1]].bel]=n-size[tr[1]];
    int x,f,son,mid;
    for(int i=2;i<=S;i++)
    {
        x=tr[i];f=fa[x];
        son=find(x,dep[f]+1);
        le[f]-=size[son];
        if(g[x].bel==g[f].bel)ans[g[x].bel]+=size[son]-size[x];else
        {
            tt=g[x].dis+g[f].dis+v[x];
            //mid=dep[x]-(tt>>1)+g[x].dis;
            //if(!(tt&1) && g[f].bel<g[x].bel)mid++;
            mid=dep[f]-g[f].dis+(tt>>1);
            if((tt&1) || g[f].bel<g[x].bel)mid++;
            tt=find(x,mid);
            ans[g[x].bel]+=size[tt]-size[x];
            ans[g[f].bel]+=size[son]-size[tt];
        }
    }
    for(int i=1;i<=S;i++)
        ans[g[tr[i]].bel]+=le[tr[i]];
}

int main()
{
    _z[0]=1;
    for(int i=1;i<=19;i++)
        _z[i]=_z[i-1]<<1;

    freopen("worldtree.in","r",stdin);
    freopen("worldtree.out","w",stdout);

    read(n);
    for(int i=1;i<n;i++)
        read(x),read(y),ins(x,y),ins(y,x),size[i]=1;size[n]=1;

    dep[1]=1;dfs();
    for(int i=1;i<19;i++)
        for(int j=1;j<=n;j++)
            f[i][j]=f[i-1][f[i-1][j]];

    read(Q);
    while(Q--)
    {
        read(m);
        for(int i=1;i<=m;i++)
            read(p[i]);

        build();
        getG();
        calc();

        for(int i=1;i<=m;i++)
            write(ans[p[i]]),P(' ');
        P('\n');
    }

    return 0;
}