[HNOI2014][bzoj3572] 世界树 [虚树+dp]

题面：

传送门

思路：

一道虚树的好题，是很多虚树博客的入门题目

但是我认为这道题目出的难点和亮点不在于虚树，而在于建出虚树以后dp的思路与实现

下文中为方便描述，用势力范围来表示一个“议事处”管辖的节点集合

首先，看完题目以后一个直观的感受，就是我去考虑两个询问点之间，哪些点属于谁的势力范围，然后这样

这是个类似暴力的东西

那树上路径的中点怎么求？可以lca求出距离以后倍增

但是现在问题来了，虚树上的节点有的是询问点，有的只是询问点的lca，并不参与询问，怎么解决这个问题呢？

而且在那个初始想法中，有一些路径是势必会重复的，又怎么解决？

一个直观的想法就是把一堆路径询问简化掉

我们发现一个点终究只能属于一个询问点的势力范围，那么一条边上的节点同理

所以我们可以把重复经过同一条边的询问拆到每条虚树边上，然后对于每条虚树边来考虑解题

显然，虚树边分为两种：两边的虚树点被同一个节点控制的，或者两端被不同节点控制的

对于两端被同一个询问点控制的边，显然这条虚树边上的所有的点的所有子树都被这个点控制

另一种情况则是在中间有一个分界线，界线一边的点与它们的子树被那一边的端点的“主人”控制

那么也就是说，我们只需要处理出虚树上的每一个节点被哪个询问点控制，然后对于上面的两种情况分别考虑、统计答案就行了

那么怎么处理这个控制关系呢？

我们做两次dfs

第一次，我们求出某个虚树节点的所有儿子中离它最近的控制点

第二次，则用父亲的控制点（和儿子不在同一个子树中）来更新儿子的控制点

dp的时候则是依然用倍增来实现跳到分界点上

两个点之间的距离则可以用lca实现

大概就是这样了，更具体的内容可以参考代码

Code：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#define ll long long
#define inf 1e9
using namespace std;
inline int read(){
    int re=0,flag=1;char ch=getchar();
    while(ch>'9'||ch<'0'){
        if(ch=='-') flag=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9') re=(re<<1)+(re<<3)+ch-'0',ch=getchar();
    return re*flag;
}
int n,dep[300010],siz[300010],st[300010][20],dfn[300010],clk;
struct graph{
    int first[300010],cnt;
    struct edge{
        int to,next;
    }a[600010];
    inline void add(int u,int v){
        if(u==v) return;
        a[++cnt]=(edge){v,first[u]};first[u]=cnt;
    }
    graph(){
        memset(first,-1,sizeof(first));cnt=0;
    }
    void init(){cnt=0;}
}G,g;
void dfs(int u,int f){
//  cout<<"begin dfs "<<u<<endl;
    int i,v;
    dep[u]=dep[f]+1;st[u][0]=f;dfn[u]=++clk;siz[u]=1;
    for(i=G.first[u];~i;i=G.a[i].next){
        v=G.a[i].to;
        if(v==f) continue;
        dfs(v,u);siz[u]+=siz[v];
    }
//  cout<<"end of dfs "<<u<<ends<<dep[u]<<ends<<siz[u]<<endl;
    return;
}
void ST(){
    int i,j;
    for(j=1;j<=19;j++) for(i=1;i<=n;i++) st[i][j]=st[st[i][j-1]][j-1];
}
int lca(int l,int r){
    if(dep[l]>dep[r]) swap(l,r);
    int i;
    for(i=19;i>=0;i--) if(dep[st[r][i]]>=dep[l]) r=st[r][i];
    if(l==r) return l;
    for(i=19;i>=0;i--)
        if(st[r][i]!=st[l][i]){
            r=st[r][i];
            l=st[l][i];
        }
    return st[l][0];
}
int q[300010],ans[300010],num[300010],s[300010],top;
bool vis[300010];
bool cmp1(int l,int r){
    return dfn[l]<dfn[r];
}
bool cmp2(int l,int r){
    return num[l]<num[r];
}
int minn[300010],belong[300010],sur[300010];
int dis(int l,int r){return dep[l]+dep[r]-2*dep[lca(l,r)];}
void dfs1(int u){
    int i,v,d1,d2;belong[u]=(vis[u]?u:0);sur[u]=siz[u];
    for(i=g.first[u];~i;i=g.a[i].next){
        v=g.a[i].to;dfs1(v);
        d1=dep[belong[v]]-dep[u];d2=(belong[u]?dep[belong[u]]-dep[u]:inf);
        if(d1<d2||(d1==d2&&belong[v]<belong[u])) belong[u]=belong[v];
    }
}
void dfs2(int u){
    int i,v,d1,d2;
    for(i=g.first[u];~i;i=g.a[i].next){
        v=g.a[i].to;d1=dis(belong[u],v);d2=dis(belong[v],v);
        if(d1<d2||(d1==d2&&belong[u]<belong[v])) belong[v]=belong[u];
        dfs2(v);
    }
}
void dp(int u){
//  cout<<"enter dp "<<u<<ends<<belong[u]<<endl;
    int i,v,d1,d2,mid,tv,j,tmp;
    for(i=g.first[u];~i;i=g.a[i].next){
        v=g.a[i].to;g.first[u]=g.a[i].next;mid=tv=v;
//      cout<<"going to "<<v<<endl;
        dp(v);
        for(j=19;j>=0;j--) if(dep[st[tv][j]]>dep[u]) tv=st[tv][j];
        sur[u]-=siz[tv];
//      cout<<"edge up to "<<tv<<endl;
        if(belong[u]==belong[v]){
            ans[belong[u]]+=siz[tv]-siz[v];continue;
        }
        for(j=19;j>=0;j--){
            tmp=st[mid][j];if(dep[tmp]<=dep[u]) continue;
            d1=dis(tmp,belong[v]);d2=dis(tmp,belong[u]);
            if(d1<d2||(d1==d2&&belong[v]<belong[u])) mid=tmp;
        }
//      cout<<"********diff edge "<<mid<<endl;
        ans[belong[u]]+=siz[tv]-siz[mid];
        ans[belong[v]]+=siz[mid]-siz[v];
    }
//  cout<<"end of dp "<<u<<ends<<sur[u]<<endl;
    ans[belong[u]]+=sur[u];
}
void solve(){
//  cout<<"*************************enter solve
";
    int m=read(),i,grand;
    for(i=1;i<=m;i++) q[i]=read(),num[q[i]]=i,vis[q[i]]=1;;
    sort(q+1,q+m+1,cmp1);top=0;g.init();s[++top]=1;
    for(i=1;i<=m;i++){
//      if(!top){s[++top]=q[i];continue;}
        grand=lca(s[top],q[i]);
        while(1){
            if(dep[s[top-1]]<=dep[grand]){
                g.add(grand,s[top--]);
                if(s[top]!=grand) s[++top]=grand;
                break;
            }
            g.add(s[top-1],s[top]);top--;
        }
        if(s[top]!=q[i]) s[++top]=q[i];
    }
    while(--top>=1) g.add(s[top],s[top+1]); 
    dfs1(s[1]);dfs2(s[1]);dp(s[1]);
    sort(q+1,q+m+1,cmp2);
//  for(i=1;i<=m;i++) cout<<q[i]<<ends;cout<<endl;
    for(i=1;i<=m;i++) vis[q[i]]=0,num[q[i]]=inf,printf("%d ",ans[q[i]]),ans[q[i]]=0;
    puts("");
}
int main(){
//  cout<<"begin
";
    int i,t1,t2;
    n=read();memset(num,0x3f,sizeof(num));
//  cout<<"input n "<<n<<endl;
    for(i=1;i<n;i++){
        t1=read();t2=read();
        G.add(t1,t2);G.add(t2,t1);
    }
//  cout<<"input of tree end
";
    dfs(1,0);ST();
    int Q=read();
    for(i=1;i<=Q;i++) solve();
}