BZOJ 3572 [HNOI2014]世界树 (虚树+DP)

题面：BZOJ传送门 洛谷传送门

题目大意：略

 

细节贼多的虚树$DP$

 

先考虑只有一次询问的情况

一个节点$x$可能被它子树内的一个到x距离最小的特殊点管辖，还可能被管辖fa[x]的特殊点管辖

跑两次$dfs$即可，时间$O(n)$

 

再考虑一条链的情况

一条链上有很多个特殊点，相邻两个特殊点$x,y$之间可能有很多连续的非特殊点，那么在这些连续的非特殊点上会有一个分界，前面一部分被$x$管辖，后面一部分被$y$管辖

在链上二分即可，时间$O(mlogm)$

 

正解就是把上面两种情况结合起来..用虚树维护一下

首先根据套路对特殊点建出虚树，虚树上会出现所有的特殊点以及一些作为$LCA$的非特殊点。

用第一种情况的方法在虚树上搜索一遍，求出虚树上的每个节点被哪些节点管辖

再考虑剩余节点的贡献

对于虚树上相邻的两个节点$x,y$，假设$dep[x]<dep[y]$，我们取出原树上端点为$x,y$的链$F$，然后把$F$的两个端点$x,y$去掉，贡献分为两种情况

$x,y$被同一个的节点管辖，那么链F上的节点以及链F上挂着的子树也都会被这个节点管辖

$x,y$被不同的节点管辖，借用第二种情况的方法，链F上一定存在一个分界点，上面一部分被管辖x的节点管辖，下面一部分被管辖y的节点管辖，倍增跳一下即可

看起来很好写，实际上细节真的不少啊..上午迷迷糊糊写+调了4h才过

 

#include <cstdio>
#include <cstring>
#include <algorithm>
#define ll long long 
#define N1 300100
using namespace std;
const int inf=0x3f3f3f3f;
 
template <typename _T> void read(_T &ret)
{
    ret=0; _T fh=1; char c=getchar();
    while(c<'0'||c>'9'){ if(c=='-') fh=-1; c=getchar(); }
    while(c>='0'&&c<='9'){ ret=ret*10+c-'0'; c=getchar(); }
    ret=ret*fh;
}
template <typename _T> _T chkmin(_T &x,_T &y,_T vx,_T vy)
{
    if(vx<vy) return x;
    if(vx>vy) return y;
    return x<y?x:y;
}
 
struct Edge{
int to[N1*2],nxt[N1*2],head[N1],cte;
void ae(int u,int v)
{ cte++; to[cte]=v; nxt[cte]=head[u]; head[u]=cte; } //val[cte]=w; 
void clr()
{ memset(to,0,(cte+1)*4); memset(nxt,0,(cte+1)*4); cte=0; } 
}e,g;
 
int n,de;
int lg[N1*2];
int dep[N1],ff[N1][20],eu[N1*2][20],st[N1],sz[N1],cur;
 
void dfs(int x)
{
    int j,v; ff[x][0]=x; eu[st[x]=++cur][0]=x; 
    for(j=e.head[x];j;j=e.nxt[j])
    {
        v=e.to[j]; if(v==ff[x][1]) continue;
        ff[v][1]=x; dep[v]=dep[x]+1; 
        dfs(v); 
        eu[++cur][0]=x; sz[x]+=sz[v];
    }
    sz[x]++;
}
void get_st()
{
    int i,j;
    for(j=2;j<=18;j++)
    for(i=1;i<=n;i++)
        ff[i][j]=ff[ ff[i][j-1] ][j-1];
    for(i=2,lg[1]=0;i<=cur;i++) lg[i]=lg[i>>1]+1;
    for(j=1;j<=lg[cur];j++)
    for(i=1;i+(1<<j)-1<=cur;i++)
        eu[i][j]=dep[eu[i][j-1]] < dep[eu[i+(1<<(j-1))][j-1]] ? eu[i][j-1] : eu[i+(1<<(j-1))][j-1];
}
int LCA(int x,int y)
{
    x=st[x], y=st[y]; if(x>y) swap(x,y); int l=y-x+1;
    return dep[eu[x][lg[l]]] < dep[eu[y-(1<<lg[l])+1][lg[l]]] ? eu[x][lg[l]] : eu[y-(1<<lg[l])+1][lg[l]];
}
int Dis(int x,int y)
{
    if(!x||!y) return inf; int F=LCA(x,y);
    return dep[x]+dep[y]-2*dep[F];
}
int jump(int x,int D)
{
    int i;
    for(i=lg[dep[x]-D]+1;i>=0;i--)
        if(ff[x][i] && dep[ff[x][i]]>=D) x=ff[x][i];
    return x;
}
 
namespace virtree{
 
int cmp_dfsorder(int x,int y){ return st[x]<st[y]; }
int vir[N1],num,stk[N1],tp,ctrl[N1],spe[N1],ans[N1],org[N1],dctrl[N1];
 
void push(int x)
{
    int y=stk[tp], F=LCA(x,y); stk[0]=F;
    while(tp>0 && dep[stk[tp-1]]>dep[F])
    {
        g.ae(stk[tp-1],stk[tp]); 
        stk[tp]=0; tp--;
    }
    if(dep[stk[tp]]>dep[F])
    {
        g.ae(F,stk[tp]); 
        stk[tp]=0; tp--;
    }
    if(!tp||stk[tp]!=F) stk[++tp]=F;
    if(stk[tp]!=x) stk[++tp]=x;
}
int build()
{
    int i;
    for(i=1;i<=num;i++) spe[vir[i]]=1, org[i]=vir[i]; 
    if(!spe[1]) vir[++num]=1;
    sort(vir+1,vir+num+1,cmp_dfsorder);
    stk[++tp]=vir[1];
    for(i=2;i<=num;i++) push(vir[i]);
    while(tp>1) g.ae(stk[tp-1],stk[tp]), tp--; 
    return stk[tp];
}
 
int dfs_son(int x)
{
    int j,v,mi=0;
    for(j=g.head[x];j;j=g.nxt[j])
    {
        v=g.to[j]; dfs_son(v);
        mi=chkmin(ctrl[v],mi,dep[ctrl[v]],dep[mi]);
    }
    ctrl[x]=(spe[x]?x:mi); 
    return ctrl[x];
}
void dfs_fa(int x)
{
    int j,v;
    for(j=g.head[x];j;j=g.nxt[j])
    {
        v=g.to[j];
        ctrl[v]=chkmin(ctrl[x],ctrl[v],Dis(ctrl[x],v),Dis(ctrl[v],v));
        dfs_fa(v);
    }
}
void debug(int x)
{
    int j,v;
    if(spe[x]) printf("%d ",x);
    for(j=e.head[x];j;j=e.nxt[j])
    {
        v=e.to[j]; if(v==ff[x][1]) continue;
        debug(v);
    }
}
void dfs_ans(int x)
{
    int j,v,sum=sz[x],cx=ctrl[x]; dctrl[x]=Dis(x,ctrl[x]);
    for(j=g.head[x];j;j=g.nxt[j])
    {
        v=g.to[j]; dfs_ans(v);
        int cv=ctrl[v],p,pv,tmp;
        pv=jump(v,dep[x]+1);
        sum-=sz[pv];
        if(dep[v]==dep[x]+1) continue; 
        if(cx!=cv){
            tmp=dctrl[x]+dctrl[v]+dep[v]-dep[x]; 
            if(tmp&1){
                p=dep[v]-((tmp-1)/2-dctrl[v]);
                p=jump(v, min(dep[v],max(dep[x]+1,p)) );
            }else{
                p=dep[v]-((tmp-1)/2-dctrl[v]);
                if(p<=dep[v]){
                    p=jump(v, min(dep[v],max(dep[x]+1,p)) );
                    if(cv<cx && dep[p]-1>=dep[x]+1) p=ff[p][1];
                }else p=v; 
            }
            ans[cx]+=sz[pv]-sz[p], ans[cv]+=sz[p]-sz[v];
        }else{
            ans[cx]+=sz[pv]-sz[v];
        }
    }
    ans[cx]+=sum;
}
void dfs_clear(int x)
{
    int j,v;
    for(j=g.head[x];j;j=g.nxt[j])
    {
        v=g.to[j]; dfs_clear(v);
    }
    g.head[x]=ctrl[x]=spe[x]=ans[x]=0;
}
 
void solve(int Num)
{
    num=Num;
    int root=build(),i; 
    dfs_son(root); 
    dfs_fa(root);
    dfs_ans(root);
    for(i=1;i<=Num;i++) if(i!=Num) printf("%d ",ans[org[i]]); else printf("%d\n",ans[org[i]]);
    dfs_clear(root);
    memset(vir,0,(num+1)*4); memset(org,0,(num+1)*4); memset(stk,0,(tp+1)*4); g.clr(); tp=0;
}
 
};
 
int main()
{
    int i,j,ans=0,x,y,q,Q;
    scanf("%d",&n);
    for(i=1;i<n;i++) read(x), read(y), e.ae(x,y), e.ae(y,x);
    dfs(1); get_st(); dep[0]=inf;
    scanf("%d",&Q); 
    for(q=1;q<=Q;q++)
    {
        read(x);
        for(i=1;i<=x;i++) read(virtree::vir[i]);
        virtree::solve(x);
    }
    return 0;
}