BZOJ3572 [Hnoi2014]世界树

3572: [Hnoi2014]世界树

Time Limit: 20 Sec   Memory Limit: 512 MB
Submit: 2625   Solved: 1461
[ Submit][ Status][ Discuss]

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

Source

[ Submit][ Status][ Discuss] 
HOME Back

---

题解

同虚树的题目一样，这道题显然是先要建出虚树，然后复杂度就只和关键点有关了。显然是一个分类讨论的过程。

我们在虚树上dfs一遍，得到每个点从属于哪个节点。之后我们只要统计不在虚树中的点（在虚树中的点上面统计了下面不作考虑）。

考虑虚树上的每一条边，先减掉这条边对应原树上节点的贡献。

1. 如果这边两个端点同属于一个节点，那么只要把贡献加回来即可。
2. 假如两个点不属于同一节点，那么显然中间会存在分界点，倍增地找出这个分界点mid，然后两边分别计算贡献就可以了。

显然还有的节点是不需要讨论的（一棵子树连在一个节点上的样子），考虑把它们计入贡献的方法。还需要记一个g数组表示子树中这些不需要讨论就可以直接判定给自己贡献的节点数。只要把初值设为size，在上面讨论的时候就把讨论的部分删掉即可。

时间复杂度\(O((n+\sum m)\log n)\)，贴一下别人的代码，改了命名，这种题没什么可做的。

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
typedef long long LL;
const int MAXN = 300011;
const int MAXM = 600011;
int n,tot,next[MAXM],to[MAXM],head[MAXN],dfn[MAXN],size[MAXN],dep[MAXN],f[MAXN][19];
int m,a[MAXN],b[MAXN],belong[MAXN],stack[MAXN],top,g[MAXN],ans[MAXN],cnt,c[MAXN];
inline void add_edge(int x,int y){ if(x==0 || x==y) return ; next[++tot]=head[x]; head[x]=tot; to[tot]=y; }
inline bool cmp(int x,int y){ return dfn[x]<dfn[y]; }
inline int read(){
    int w=0,q=0; char c=getchar(); while((c<'0'||c>'9') && c!='-') c=getchar();
    if(c=='-') q=1,c=getchar(); while (c>='0'&&c<='9') w=w*10+c-'0',c=getchar(); return q?-w:w;
}
 
inline void init(int x,int fa){
    size[x]=1; dfn[x]=++tot;
    for(int i=head[x];i;i=next[i]) {
        int v=to[i]; if(v==fa) continue;
        f[v][0]=x; dep[v]=dep[x]+1;
        init(v,x); size[x]+=size[v];
    }
}
 
inline int lca(int x,int y){
    if(dep[x]<dep[y]) swap(x,y); int t=0; while((1<<t)<=dep[x]) t++; t--;
    for(int i=t;i>=0;i--) if(dep[x]-(1<<i)>=dep[y]) x=f[x][i]; if(x==y) return x;
    for(int i=t;i>=0;i--) if(f[x][i]!=f[y][i]) x=f[x][i],y=f[y][i]; return f[x][0];
}
 
inline int dis(int x,int y){ return dep[x]+dep[y]-dep[lca(x,y)]*2; }
 
inline void dfs_down(int x,int fa){
    int d1,d2; g[x]=size[x]; c[++cnt]=x;
    for(int i=head[x];i;i=next[i]) {
        int v=to[i]; if(v==fa) continue;
        dfs_down(v,x);
        if(belong[x]==0) { belong[x]=belong[v]; continue; }//注意不要出0了
        d1=dis(belong[v],x); d2=dis(belong[x],x);
        if(d1<d2 || (d1==d2 && belong[v]<belong[x])) belong[x]=belong[v];
    }
}
 
inline void dfs_up(int x,int fa){
    int d1,d2;
    for(int i=head[x];i;i=next[i]) {
        int v=to[i]; if(v==fa) continue;
        d1=dis(belong[v],v); d2=dis(belong[x],v);
        if(d1>d2 || (d1==d2 && belong[v]>belong[x])) belong[v]=belong[x];
        //必须先划分再下传！不然会有问题！
        dfs_up(v,x); 
    }
}
 
inline void solve(int fa,int u){//讨论(fa,u)这条边
    int son=u,mid=u,nex,d1,d2;
    for(int i=18;i>=0;i--)//son是fa到u的路径上的第一个节点，也就是一个原树上的儿子节点
        if(dep[son]-(1<<i)>dep[fa])
            son=f[son][i];
 
    g[fa]-=size[son];//减去加入讨论的部分，保留仍未讨论的部分，是size而不是g!
    if(belong[fa]==belong[u]) { ans[belong[fa]]+=size[son]-size[u]; return ; }
    for(int i=18;i>=0;i--) {//寻找分界点
        nex=f[mid][i]; if(dep[nex]<=dep[fa]) continue;
        d1=dis(nex,belong[fa]); d2=dis(nex,belong[u]);
        if(d1>d2 || (d1==d2 && belong[u]<belong[fa])) mid=nex;
    }
    ans[belong[fa]]+=size[son]-size[mid];
    ans[belong[u]]+=size[mid]-size[u];
}
 
inline void build(){
    m=read(); for(int i=1;i<=m;i++) a[i]=read(),b[i]=a[i];
    for(int i=1;i<=m;i++) belong[a[i]]=a[i];
    top=tot=cnt=0; sort(a+1,a+m+1,cmp); if(belong[1]!=1) stack[++top]=1;
    int LCA;
    for(int i=1;i<=m;i++) {
        if(top==0) { stack[++top]=a[i]; continue; }
        LCA=lca(stack[top],a[i]);
        while(1) {
            if(dep[stack[top-1]]<=dep[LCA]) {
                add_edge(LCA,stack[top]); top--;
                if(stack[top]!=LCA) stack[++top]=LCA;
                break;
            }
            add_edge(stack[top-1],stack[top]);
            top--;
        }
        if(stack[top]!=a[i]) stack[++top]=a[i];
    }
    while(top>1) add_edge(stack[top-1],stack[top]),top--; top--; //记得把剩下的连完边！
 
    dfs_down(1,0);
    dfs_up(1,0);
 
    //对于虚树上的每一条边进行考虑
    for(int i=1;i<=cnt;i++)
        for(int j=head[c[i]];j;j=next[j])
            solve(c[i],to[j]);
 
    for(int i=1;i<=cnt;i++) ans[belong[c[i]]]+=g[c[i]];
    for(int i=1;i<=m;i++) printf("%d ",ans[b[i]]); puts("");
    for(int i=1;i<=cnt;i++) ans[c[i]]=head[c[i]]=g[c[i]]=belong[c[i]]=0;//需要清空的是所有！不只是m
}

int main()
{
    n=read(); int x,y;
    for(int i=1;i<n;i++) { x=read(); y=read(); add_edge(x,y); add_edge(y,x); }
    tot=0; init(1,0); tot=0; memset(head,0,sizeof(head));
    for(int j=1;j<=18;j++) for(int i=1;i<=n;i++) f[i][j]=f[f[i][j-1]][j-1];
    int q=read();
    while(q--) build();
    return 0;
}