• 【BZOJ-3572】世界树 虚树 + 树形DP


    3572: [Hnoi2014]世界树

    Time Limit: 20 Sec  Memory Limit: 512 MB
    Submit: 1084  Solved: 611
    [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

    Solution

    同样是虚树+树形DP,然而这个题就很麻烦了

    首先建出虚树,然后我们可以进行树形dp,求出每个点最近的关键点(两次DFS)

    然后考虑,对于虚树上的一条边,在实际的树上,缩了很多点,那么考虑这些点的问题,需要讨论

    1.对于边<a,b>如果belong[a]==belong[b],那么边<a,b>缩掉的点,全部都被belong[a](belong[b])管辖

    2.对于边<a,b>如果belong[a]!=belong[b],那么边<a,b>缩掉的点中,有一部分被belong[a]管辖,一部分被belong[b]管辖

    对于情况1,非常好处理,至于情况2,我们需要利用倍增,去得到中间这个断点pos,然后转化成情况1去处理

    这里还有一个问题,有的子树,完全没在虚树上出现过!需要单独去考虑

    这里很显然,这些点,一定和他们的根节点同一个管辖,所以在处理上述的时候,额外记录sz[i]表示,节点i的子树中,没被访问的还有,

    在处理一部分点的时候,记得在sz[]中将其减去,然后在最后,把剩余sz[]累加入答案,既可达到全部统计的效果

    Code

    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<algorithm>
    #include<cmath>
    using namespace std;
    void Freopen() {freopen("worldtree.in","r",stdin); freopen("worldtree.out","w",stdout);}
    void Fclose() {fclose(stdin); fclose(stdout);}
    int read()
    {
        int x=0,f=1; char ch=getchar();
        while (ch<'0' || ch>'9') {if (ch=='-') f=-1; ch=getchar();}
        while (ch>='0' && ch<='9') {x=x*10+ch-'0'; ch=getchar();}
        return x*f;
    }
    #define MAXN 300010
    int N,M,Q;
    struct EdgeNode{int next,to;}edge[MAXN<<1];
    int head[MAXN],cnt;
    void AddEdge(int u,int v) {cnt++; edge[cnt].next=head[u]; edge[cnt].to=v; head[u]=cnt;}
    void InsertEdge(int u,int v) {AddEdge(u,v); AddEdge(v,u);}
    int dfn[MAXN],t,size[MAXN],deep[MAXN],father[MAXN][21];
    void DFS(int now,int last)
    {
        dfn[now]=++t; size[now]=1;
        for (int i=1; i<=20; i++)
            if (deep[now]>=(1<<i)) father[now][i]=father[father[now][i-1]][i-1];
            else break;
        for (int i=head[now]; i; i=edge[i].next)
            if (edge[i].to!=last)
                {
                    father[edge[i].to][0]=now;
                    deep[edge[i].to]=deep[now]+1;
                    DFS(edge[i].to,now);
                    size[now]+=size[edge[i].to];
                }
    }
    int LCA(int x,int y)
    {
        if (deep[x]<deep[y]) swap(x,y);
        int dd=deep[x]-deep[y];
        for (int i=0; i<=20; i++)
            if (dd&(1<<i)) x=father[x][i];
        for (int i=20; i>=0; i--)
            if (father[x][i]!=father[y][i])
                x=father[x][i],y=father[y][i];
        if (x==y) return x; else return father[x][0];
    }
    struct RoadNode{int next,to;}road[MAXN<<1];
    int last[MAXN],tot;
    void AddRoad(int u,int v) {tot++; road[tot].next=last[u]; last[u]=tot; road[tot].to=v;}
    void InsertRoad(int u,int v) {if (u==v) return; AddRoad(u,v);}
     
    int Dis(int x,int y) {return deep[x]+deep[y]-deep[LCA(x,y)]-deep[LCA(x,y)];}
    int sz[MAXN],dfsn[MAXN],belong[MAXN],dp[MAXN],a[MAXN],h[MAXN];
    void DFS_1(int now)
    {
        sz[now]=size[now];  dfsn[++t]=now;
        for (int i=last[now]; i; i=road[i].next)
            {
                DFS_1(road[i].to);
                if (!belong[road[i].to]) continue;
                int D1=Dis(now,belong[road[i].to]),D2=Dis(now,belong[now]);
                if (!belong[now] || D1<D2 || (D1==D2&&belong[road[i].to]<belong[now]))
                    belong[now]=belong[road[i].to];
            }
    }
    void DFS_2(int now)
    {
        for (int i=last[now]; i; i=road[i].next)
            {
                int D1=Dis(road[i].to,belong[now]),D2=Dis(road[i].to,belong[road[i].to]);
                if (!belong[road[i].to] || D1<D2 || (D1==D2&&belong[now]<belong[road[i].to]))
                    belong[road[i].to]=belong[now];
                DFS_2(road[i].to);
            }
    }
    void Work(int a,int b)
    {
        int x=b,pos=b;
        for (int i=20; i>=0; i--) if (deep[father[x][i]]>deep[a]) x=father[x][i];
        sz[a]-=size[x];
        if (belong[a]==belong[b]) {dp[belong[a]]+=size[x]-size[b]; return ;}
        for (int i=20; i>=0; i--)
            {
                int tmp=father[pos][i];
                if (deep[tmp]<=deep[a]) continue;
                int D1=Dis(belong[a],tmp),D2=Dis(belong[b],tmp);
                if (D1>D2 || (D1==D2&&belong[b]<belong[a])) pos=tmp;
            }
        dp[belong[a]]+=size[x]-size[pos];
        dp[belong[b]]+=size[pos]-size[b];
    }
    void DP()
    {
        DFS_1(1); DFS_2(1);
        for (int i=1; i<=t; i++)
            for (int j=last[dfsn[i]]; j; j=road[j].next)
                Work(dfsn[i],road[j].to);
        for (int i=1; i<=t; i++) dp[belong[dfsn[i]]]+=sz[dfsn[i]];
        for (int i=1; i<=M; i++) printf("%d ",dp[a[i]]); puts("");
        for (int i=1; i<=t; i++) dp[dfsn[i]]=belong[dfsn[i]]=sz[dfsn[i]]=last[dfsn[i]]=0;
    }
    int top,tp,st[MAXN];
    bool cmp(int x,int y) {return dfn[x]<dfn[y];} 
    void MakeTree(int M)
    {
        t=tot=top=0;
        for (int i=1; i<=M; i++) belong[a[i]]=a[i];
        sort(h+1,h+M+1,cmp);
        if (belong[1]!=1) st[++top]=1;
        for (int i=1; i<=M; i++)
            {
                int now=h[i],lca=0;
                while (top)
                    {
                        lca=LCA(now,st[top]);
                        if (top>1 && deep[lca]<deep[st[top-1]])
                            InsertRoad(st[top-1],st[top]),top--;
                        else if (deep[lca]<deep[st[top]])
                            {InsertRoad(lca,st[top]); top--; break;}
                        else break;
                    }
                if (st[top]!=lca) st[++top]=lca;
                st[++top]=now;
            }
        while (top>1) InsertRoad(st[top-1],st[top]),top--;
        DP();
    }
    int main()
    {
    //  Freopen();
        N=read();
        for (int x,y,i=1; i<=N-1; i++) x=read(),y=read(),InsertEdge(x,y);
        DFS(1,0);
        Q=read();
        while (Q--)
            {
                M=read();
                for (int i=1; i<=M; i++) a[i]=h[i]=read();
                MakeTree(M); 
            } 
        return 0;
    }

    写起来细节好多.....恶心死

  • 相关阅读:
    如果因特网中的所有链路都提供可靠的交付服务,TCP可靠传输服务是多余的吗?
    编译运行java程序出现Exception in thread "main" java.lang.UnsupportedClassVersionError: M : Unsupported major.minor version 51.0
    chrome浏览器插件的开启快捷键
    sqlzoo练习题答案
    2019Falg
    python绘图踩的坑
    精益数据分析--测试分析
    np.random的随机数函数
    numpy中文件的存储和读取-嵩天老师笔记
    喜欢的话
  • 原文地址:https://www.cnblogs.com/DaD3zZ-Beyonder/p/5811658.html
Copyright © 2020-2023  润新知