zoukankan      html  css  js  c++  java
  • 【题解】10-19秀秀的森林(forest)

    我恨秀秀
    倍增LCA+离线 (时光倒流)

    题目

    秀秀有一棵带n个顶点的树T,每个节点有一个点权ai-。
    有一天,她想拥有两棵树,于是她从T中删去了一条边。
    第二天,她认为三棵树或许会更好一些。因此,她又从她拥有的某一棵树中删去了一条边。
    如此往复,每一天秀秀都会删去一条尚未被删去的边,直到她得到由n棵只有一个点的树构成的
    森林。
    秀秀定义一条简单路径(节点不重复出现的路径)的权值为路径上所有点的权值之和,一棵树的
    直径为树上权值最大的简单路径。秀秀认为树最重要的特征就是它的直径。所以她想请你算出任一时
    刻她拥有的所有树的直径的乘积。因为这个数可能很大,你只需输出这个数对$10^{9}+7$取模之后的结
    果即可。

    输入输出

    输入格式
    从文件forest.in 中读入数据。

    输入的第一行包含一个整数n,表示树T 上顶点的数量。
    下一行包含n 个空格分隔的整数ai,表示顶点的权值。
    之后的n-1 行中,每一行包含两个用空格分隔的整数xi 和yi,表示节点xi 和yi 之间连有一条边,编号为i。
    再之后n-1 行中,每一行包含一个整数kj,表示在第j 天里会被删除的边的编号

    输出格式
    输出文件到forest.out 中。
    输出n 行。 
    在第i 行,输出删除i-1 条边之后,所有树直径的乘积对$10^{9}+7$ 取模的结果 

    思路

    核心:LCA+离线

    • 我们倒着来看,当删完所有的边后,每棵树的直径就是自己的点权
    • 所以有初值for(i=1—>n)ans[n]*=q[i]%mod
      • ans[n]为n次操作后的答案
      • q[i]为点i的权值
    • 然后倒着做每次操作
      • 把断边转化成连边,变成两棵树的合并,并求其合并后的直径,
      • 那么把之前的断点记录一下,用倍增 Lca O(log N) 求出哪个值最大即可。
      • 其它树的值不用都计算,只需除以两个数的值、再乘回合并后的值即可(用逆元)

    代码

    #include<cstdio>
    #include<algorithm>
    #include<cmath>
    using namespace std;
    const int N=1e5+2,mo=1e9+7;
    int tot;
    int a[N],q[N],f[N];
    int fa[N][17],len[N][17],dep[N];
    long long ans[N],v[N];           //v[i]存以i为根节点的树的直径长 
    int head[N],next[N<<1],en[N<<1];
    struct data{
        int x,y;
    }b[N],g[N],t;    //b存边两端的点,t存直径两端的结点 ,g[i]存以i为根节点的树的直径的两端的点 
    
    struct kk{
        int u,v,next;
    }e[N<<1]; 
    inline int read()
    {
        int X=0,w=1; char ch=0;
        while(ch<'0' || ch>'9') {if(ch=='-') w=-1;ch=getchar();}
        while(ch>='0' && ch<='9') X=(X<<3)+(X<<1)+ch-'0',ch=getchar();
        return X*w;
    }
    inline void write(long long x)
    {
        if(x>9) write(x/10);
        putchar(x%10+'0');
    }
    inline void add(int u,int v)
    {
        e[++tot].v=v;
        e[tot].next=head[u];
        head[u]=tot;
    
    }
    inline int get(int x)
    {
        if(f[x]==x) return x;
        return f[x]=get(f[x]);
    }
    inline void dfs(int x)
    {
        dep[x]=dep[fa[x][0]]+1;
        for(int i=head[x];i;i=e[i].next)
            if(e[i].v!=fa[x][0])
            {
                fa[e[i].v][0]=x;
                len[e[i].v][0]=a[e[i].v];
                dfs(e[i].v);
            }
    }
    inline long long fast_pow(long long x,int y)
    {
        long long s=1;
        while(y)
        {
            if(y&1) s=s*x%mo;
            x=x*x%mo;
            y>>=1;
        }
        return s;
    }
    inline int lca(int x,int y)
    {
        if(dep[x]<dep[y]) swap(x,y);
        int sum=0;
        for(int i=log2(dep[x]);i>=0;i--)
            if(dep[fa[x][i]]>=dep[y]) sum+=len[x][i],x=fa[x][i];
        if(x==y) return sum+a[x];
        for(int i=log2(dep[x]);i>=0;i--)
            if(fa[x][i]!=fa[y][i]) sum+=len[x][i]+len[y][i],x=fa[x][i],y=fa[y][i];
        sum+=len[x][0]+len[y][0]+a[fa[x][0]];
        return sum;
    }
    int main()
    {
        int n=read();
        for(int i=ans[n]=1;i<=n;i++)
        {
            v[i]=a[i]=read();
            ans[n]=ans[n]*a[i]%mo;          
            g[i].x=g[i].y=f[i]=i;
        }
        for(int i=1;i<n;i++)
        {
            b[i].x=read(),b[i].y=read();
            add(b[i].x,b[i].y);
            add(b[i].y,b[i].x);
        }
        dfs(1);
        for(int j=1;j<17;j++)
            for(int i=1;i<=n;i++)
            {
                fa[i][j]=fa[fa[i][j-1]][j-1];
                len[i][j]=len[i][j-1]+len[fa[i][j-1]][j-1];     //权值和 
            }
        for(int i=1;i<n;i++) q[i]=read();
        for(int i=n-1;i;i--)
        {
            int x=b[q[i]].x,y=b[q[i]].y;                       
            int f1=get(x),f2=get(y);
            f[f1]=f2;                                       //合并 
            ans[i]=ans[i+1]*fast_pow(v[f1],mo-2)%mo*fast_pow(v[f2],mo-2)%mo;     //逆元 
            long long mx=0;
            int s1=lca(g[f1].x,g[f2].x),s2=lca(g[f1].y,g[f2].y);    //枚举四个点之间的路径长 
            int s3=lca(g[f1].x,g[f2].y),s4=lca(g[f1].y,g[f2].x);
            if(s1>s2)
            {
                if(s1>s3)
                {
                    if(s1>s4)
                    {
                        mx=s1;
                        t.x=g[f1].x,t.y=g[f2].x;
                    }else
                    {
                        mx=s4;
                        t.x=g[f1].y,t.y=g[f2].x;
                    }
                }else
                {
                    if(s3>s4)
                    {
                        mx=s3;
                        t.x=g[f1].x,t.y=g[f2].y;
                    }else
                    {
                        mx=s4;
                        t.x=g[f1].y,t.y=g[f2].x;
                    }
                }
            }else
            {
                if(s2>s3)
                {
                    if(s2>s4)
                    {
                        mx=s2;
                        t.x=g[f1].y,t.y=g[f2].y;
                    }else
                    {
                        mx=s4;
                        t.x=g[f1].y,t.y=g[f2].x;
                    }
                }else
                {
                    if(s3>s4)
                    {
                        mx=s3;
                        t.x=g[f1].x,t.y=g[f2].y;
                    }else
                    {
                        mx=s4;
                        t.x=g[f1].y,t.y=g[f2].x;
                    }
                }
            }
            if(v[f1]>mx) mx=v[f1],t=g[f1];    //也有可能合并前后直径并没有改变 
            if(v[f2]>mx) mx=v[f2],t=g[f2];
            ans[i]=ans[i]*mx%mo;
            v[f2]=mx;
            g[f2]=t;
        }
        for(int i=1;i<=n;i++) write(ans[i]),putchar('
    ');
        return 0;
    }
    
  • 相关阅读:
    【English】20190307
    【Teradata】四舍五入函数
    【Teradata】配置PE和AMP(congfig和reconfig工具、vprocmanager)
    【English】20190306
    【Teradata】数据库初始化(sysinit和dip工具)
    【Teradata】日期类型转换
    Optional常用操作
    Stream学习笔记
    拦截Restful API的三种方式
    maven之可执行jar包
  • 原文地址:https://www.cnblogs.com/bbqub/p/7699028.html
Copyright © 2011-2022 走看看