[BZOJ3572][HNOI2014]世界树-虚树+树形DP

世界树

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]的临时议事处管理的种族个数。

Sample Input

10
2 1
3 2
4 3
5 4
6 1
7 3
8 3
9 4
10 1
5
2
6 1
5
2 7 3 6 9
1
8
4
8 7 10 3
5
2 9 3 5 8

Sample Output

1 9
3 1 4 1 1
10
1 1 3 5
4 1 3 1 1

HINT

N<=300000, q<=300000,m[1]+m[2]+…+m[q]<=300000

---

从早上写到下午，整整200+行的超工业、细节超多代码重构了整整两次，交了十多个版本的标程在某洛谷上全部TLE4个点,咱的内心是崩溃的……

(╯‵□′)╯︵┻━┻︵┻━┻︵┻━┻︵┻━┻︵┻━┻︵┻━┻

---

思路:
首先咱观察总询问点数……好像不多？？
给人一种钦定虚树的感觉。
那么，先对每次询问建一波虚树吧。

然后，先把虚树上点的关系搞一搞吧~用树形DP正着反着搜一波，预处理出所有虚树上点属于哪个临时议事处。
接着，考虑到所有被咱忽略掉的点，全都会要么夹在某两个虚树上的点中间，要么是某个虚树节点向下走到叶子~
然后我们枚举虚树上的每条边，有两种情况:
1、两个端点属于同一临时议事处。
显然这条边上的所有点全都属于端点的临时议事处……
2、两个端点不属于同一临时议事处。
那么显然可以二分出这条边上所属议事处不同的位置，加一加~

最后，有些点（就是第二个”要么”）显然没有被处理，显然它们所属的临时议事处就是它们在虚树上的父亲所属的临时议事处，直接加进对应的答案即可~

实现上，开一个undone(下面的und)数组记录未被考虑的点，初始化为子树大小，在枚举边的过程中一步步减掉，最后一起加上就好~

另外，递归版会超时。
这是用网上十几个标程，以及咱的第一份代码得出的结论。
于是改为按dfs序枚举就可以过了~
(然而自带巨大常数，只是O(勉强能过))
(另外拥有高深卡常技巧的dalao可以试着卡一卡递归版，咱这么弱显然超时)

还有最后一点:输出如果每行末尾没有空格而是直接换行在BZOJ上会PE……

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0' || '9'<ch){if(ch=='-')f=-1;ch=getchar();}
    while('0'<=ch && ch<='9'){x=x*10+(ch^48);ch=getchar();}
    return x*f;
}

const int N=300009;
const int K=19;
const int Inf=1e9;

int n;

int to[N<<1],nxt[N<<1],beg[N],tot;
int list[N],stk[N],top;
int dfn[N],dfe[N],siz[N],dep[N];
int ask[N],ans[N],und[N];
int fa[N][K],fas[N],fadis[N];
int belong[N],bedis[N];

inline void adde(int u,int v)
{
    to[++tot]=v;
    nxt[tot]=beg[u];
    beg[u]=tot;
}

inline void add(int u,int v)
{
    adde(u,v);adde(v,u);
}

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

inline void dfs(int u)
{
    dfn[u]=++tot;
    siz[u]=1;

    for(int i=beg[u],v;i;i=nxt[i])
        if((v=to[i])!=fa[u][0])
        {
            fa[v][0]=u;
            dep[v]=dep[u]+1;

            dfs(v);
            siz[u]+=siz[v];
        }

    dfe[u]=tot;
}

inline int lca(int a,int b)
{
    if(dep[a]<dep[b])swap(a,b);
    int delta=dep[a]-dep[b];

    for(int i=0;i<K;i++)
        if((1<<i)&delta)
            a=fa[a][i];
    if(a==b)return a;

    for(int i=K-1;i>=0;i--)
        if(fa[a][i]!=fa[b][i])
            a=fa[a][i],b=fa[b][i];
    return fa[a][0];
}

inline int dist(int a,int b)
{
    return dep[a]+dep[b]-(dep[lca(a,b)]<<1);
}

int main()
{
    n=read();
    for(int i=1;i<n;i++)
        add(read(),read());

    tot=0;
    dep[1]=1;dfs(1);
    for(int i=1;i<K;i++)
        for(int j=1;j<=n;j++)
            fa[j][i]=fa[fa[j][i-1]][i-1];

    memset(beg,0,sizeof(beg));

    int q=read();
    while(q--)
    {
        tot=0;

        int qcnt=read();
        for(int i=1;i<=qcnt;i++)
            list[i]=ask[i]=read();

        int list_lim=qcnt;
        sort(list+1,list+list_lim+1,cmp);
        for(int i=1,e=list_lim;i<e;i++)
            list[++list_lim]=lca(list[i],list[i+1]);
        list[++list_lim]=1;

        sort(list+1,list+list_lim+1,cmp);
        list_lim=unique(list+1,list+list_lim+1)-list-1;

        stk[top=1]=1;
        for(int i=2;i<=list_lim;i++)
        {
            while(top && dfn[list[i]]>dfe[stk[top]])
                top--;

            fas[list[i]]=stk[top];
            adde(stk[top],list[i]);
            stk[++top]=list[i];
        }

        for(int i=1;i<=list_lim;i++)
        {
            belong[list[i]]=0;
            bedis[list[i]]=Inf;
            und[list[i]]=siz[list[i]];

            if(i>1)
                fadis[list[i]]=dep[list[i]]-dep[fas[list[i]]];
        }
        for(int i=1;i<=qcnt;i++)
            belong[ask[i]]=ask[i],bedis[ask[i]]=0;

        for(int i=list_lim;i>=2;i--)
        {
            if(bedis[fas[list[i]]]>bedis[list[i]]+fadis[list[i]] || (bedis[fas[list[i]]]==bedis[list[i]]+fadis[list[i]] && belong[list[i]]<belong[fas[list[i]]]))
            {
                bedis[fas[list[i]]]=bedis[list[i]]+fadis[list[i]];
                belong[fas[list[i]]]=belong[list[i]];
            }
        }

        for(int i=2;i<=list_lim;i++)
            if(bedis[list[i]]>bedis[fas[list[i]]]+fadis[list[i]] || (bedis[list[i]]==bedis[fas[list[i]]]+fadis[list[i]] && belong[fas[list[i]]]<belong[list[i]]))
            {
                bedis[list[i]]=bedis[fas[list[i]]]+fadis[list[i]];
                belong[list[i]]=belong[fas[list[i]]];
            }

        for(int i=1;i<=list_lim;i++)
        {
            int u=list[i],faa=fas[u];

            if(faa==0)
                ans[belong[u]]+=n-siz[u];
            else
            {
                int son=u;
                for(int i=K-1;i>=0;i--)
                    if(dep[fa[son][i]]>=dep[faa]+1)
                        son=fa[son][i];

                und[faa]-=siz[son];
                if(belong[u]==belong[faa])
                    ans[belong[u]]+=siz[son]-siz[u];
                else
                {
                    int dis=(bedis[faa]-bedis[u]+fadis[u])>>1,mid;
                    if(dis+bedis[u]==bedis[faa]+fadis[u]-dis && belong[u]>belong[faa])
                        --dis;

                    mid=u;
                    for(int i=K-1;i>=0;i--)
                        if(dep[fa[mid][i]]>=dep[u]-dis)
                            mid=fa[mid][i];

                    ans[belong[faa]]+=siz[son]-siz[mid];
                    ans[belong[u]]+=siz[mid]-siz[u];
                }
            }
        }

        for(int i=1;i<=list_lim;i++)
            ans[belong[list[i]]]+=und[list[i]];
        for(int i=1;i<=qcnt;i++)
            printf("%d ",ans[ask[i]]),ans[ask[i]]=0;
        puts("");
    }

    return 0;
}