bzoj 3572: [Hnoi2014]世界树 虚树

题目:

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年的时间里，每一年完成授权后，当年每个临时议事处将会管理多少个种族（议事处所在的聚居地也将接受该议事处管理）。 现在这个任务交给了以智慧著称的灵长类的你：程序猿。请帮国王完成这个任务吧。

题解:

首先构建出虚树来.

然后我们考虑统计答案.

我们发现我们要做的就是把每一条边上所含的非虚树点给分到两端上

容易发现这条边一定是从某一个点劈开,两端分别分给两端。

所以我们考虑在每条边上二分即可..

是不是很简单 ~~~

反正我是快写死了..

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
inline void read(int &x){
    x=0;char ch;bool flag = false;
    while(ch=getchar(),ch<'!');if(ch == '-') ch=getchar(),flag = true;
    while(x=10*x+ch-'0',ch=getchar(),ch>'!');if(flag) x=-x;
}
const int maxn = 300010;
const int inf = 0x3f3f3f3f;
int siz[maxn],son[maxn],dep[maxn],fa[maxn][22];
int top[maxn],mn[maxn],mnid[maxn],ans[maxn];
int dfn[maxn],dfs_clock,res[maxn],c[maxn],tot;
bool col[maxn];
struct Graph{
    struct Edge{
        int to,next;
    }G[maxn<<1];
    int head[maxn],cnt;
    void add(int u,int v){
        G[++cnt].to = v;
        G[cnt].next = head[u];
        head[u] = cnt;
    }
#define v G[i].to
    void dfs(int u){
        siz[u] = 1;
        for(int i = head[u];i;i=G[i].next){
            if(v == fa[u][0]) continue;
            fa[v][0] = u;
            dep[v] = dep[u] + 1;
            dfs(v);
            siz[u] += siz[v];
            if(siz[son[u]] < siz[v]) son[u] = v;
        }
    }
    void dfs(int u,int tp){
        top[u] = tp;dfn[u] = ++ dfs_clock;
        if(son[u]) dfs(son[u],tp);
        for(int i = head[u];i;i=G[i].next){
            if(v == son[u] || v == fa[u][0]) continue;
            dfs(v,v);
        }
    }
    void dfs1(int u,int f){
        mn[u] = inf;mnid[u] = 0;res[u] = siz[u];
        c[++tot] = u;
        for(int i = head[u];i;i=G[i].next){
            if(v == f) continue;
            dfs1(v,u);int d = dep[v] - dep[u];
            if(mn[u] > mn[v] + d){
                mn[u] = mn[v] + d;
                mnid[u] = mnid[v];
            }else if(mn[u] == mn[v] + d && mnid[u] > mnid[v]){
                mnid[u] = mnid[v];
            }
        }
        if(col[u]){
            mn[u] = 0;
            mnid[u] = u;
        }
    }
    void dfs2(int u,int f,int num,int numid){
        if(mn[u] > num){
            mn[u] = num;
            mnid[u] = numid;
        }else if(mn[u] == num && mnid[u] > numid){
            mnid[u] = numid;
        }
        for(int i = head[u];i;i=G[i].next){
            if(v == f) continue;
            int d = dep[v] - dep[u];
            dfs2(v,u,mn[u]+d,mnid[u]);
        }
    }

#undef v
}g1,g2;
inline void solve(int f,int u){
    int x = u;
    for(int j = 18;~j;--j){
        if(dep[fa[x][j]] > dep[f]){
            x = fa[x][j];
        }
    }res[f] -= siz[x];
    if(mnid[f] == mnid[u]){
        ans[mnid[f]] += siz[x] - siz[u];
        return ;
    }
    int y = u;
    for(int j = 18;~j;--j){
        if(dep[fa[y][j]] <= dep[f]) continue;
        int du = mn[u] + dep[u] - dep[fa[y][j]];
        int df = mn[f] + dep[fa[y][j]] - dep[f];
        if(du < df || (du == df && mnid[u] < mnid[f])) y = fa[y][j];
    }
    ans[mnid[f]] += siz[x] - siz[y];
    ans[mnid[u]] += siz[y] - siz[u];
}
inline int lca(int u,int v){
    while(top[u] != top[v]){
        if(dep[top[u]] < dep[top[v]]) swap(u,v);
        u = fa[top[u]][0];
    }return dep[u] < dep[v] ? u : v;
}
inline bool cmp(const int &i,const int &j){
    return dfn[i] < dfn[j];
}
int sta[maxn],a[maxn],b[maxn];
int main(){
    int n;read(n);
    for(int i=1,u,v;i<n;++i){
        read(u);read(v);
        g1.add(u,v);
        g1.add(v,u);
    }
    g1.dfs(1);g1.dfs(1,1);
    fa[1][0] = 1;
    for(int j=1;j<=18;++j){
        for(int i=1;i<=n;++i){
            fa[i][j] = fa[fa[i][j-1]][j-1];
        }
    }
    int q;read(q);
    int top = 0;
    while(q--){
        int num;read(num);g2.cnt = 0;tot = 0;top = 0;
        for(int i=1;i<=num;++i){
            read(a[i]);b[i] = a[i];
            col[a[i]] = true;
        }
        sort(a+1,a+num+1,cmp);
        if(a[1] != 1) sta[++top] = 1;
        for(int i=1;i<=num;++i){
            if(top == 0) sta[++top] = a[i];
            else{
                int lc = lca(sta[top],a[i]);
                while(dfn[sta[top]] > dfn[lc]){
                    if(dfn[sta[top-1]] <= dfn[lc]){
                        g2.add(lc,sta[top]);
                        if(sta[--top] != lc) sta[++top] = lc;
                        break;
                    }
                    g2.add(sta[top-1],sta[top]);
                    -- top;
                }sta[++top] = a[i];
            }
        }
        while(top > 1) g2.add(sta[top-1],sta[top]),--top;
        g2.dfs1(sta[1],sta[1]);
        g2.dfs2(sta[1],sta[1],mn[1]+1,mnid[1]);
        for(int i=1,u;i<=tot;++i){
            u = c[i];
            for(int j = g2.head[u];j;j=g2.G[j].next){
                solve(u,g2.G[j].to);
            }
        }
        for(int i=1,u;i<=tot;++i){
            u = c[i];
            ans[mnid[u]] += res[u];
            res[u] = 0;col[u] = 0;
            g2.head[u] = 0;
        }
        for(int i=1;i<=num;++i){
            printf("%d ",ans[b[i]]);
            ans[b[i]] = 0;
        }puts("");
    }
    return 0;
}