9.24 NOIP模拟——“单”

最新推荐文章于 2021-11-21 15:48:42 发布

原创最新推荐文章于 2021-11-21 15:48:42 发布 · 374 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#考试

------模拟考试----- 专栏收录该内容

7 篇文章

订阅专栏

本文介绍了一种解决特殊单源最短路径问题的方法，通过预处理和递归计算简化了问题复杂度，实现了高效求解。

单（single）

最开始看到这道题的想法——单源最短路？？高斯消元？？
最后看题解发现这些都不用……

t=0时
先暴力求出b[1]的值
经过观察可发现
b[son]=b[fa]-suma[son]+(SUMA-suma[son])
=b[fa]+SUMA-2*suma[son]

t=1时
已知 b[son]-b[fa]=SUMA-2*suma[son]
设 k[son]=SUMA-2*suma[son]
因为 sigma suma[i]（i不为根）=b[root]
所以 sigma k[i]=(n-1)*SUMA-2*sigma suma[v]=tot
sigma k[i]=(n-1)SUMA-2*b[1]=tot
可得SUMA
a[i]易得

#include<cstdio>
#include<cstring>
using namespace std;
const int N=100000+5,M=2*N;
int n;
int nxt[M],to[M],head[N],etot;
int a[N],b[N],dep[N];
int suma[N],SUMA,k[N];
void adde(int u,int v)
{
    to[++etot]=v;
    nxt[etot]=head[u];
    head[u]=etot;
}
void dfs_t0(int u,int fa)
{
    suma[u]+=a[u];
    for(int i=head[u];i;i=nxt[i]){
        int v=to[i];
        if(v==fa) continue;
        dep[v]=dep[u]+1; 
        dfs_t0(v,u);
        suma[u]+=suma[v];
    }
}
void dfs_b(int u,int fa)
{
    for(int i=head[u];i;i=nxt[i]){
        int v=to[i];
        if(v==fa) continue;
        b[v]=b[u]+SUMA-2*suma[v];
        dfs_b(v,u);
    }
}
void dfs_t1(int u,int fa)
{
    for(int i=head[u];i;i=nxt[i]){
        int v=to[i];
        if(v==fa) continue;
        k[v]=b[v]-b[u];
        dfs_t1(v,u);
    }
}
void dfs_a(int u,int fa)
{
    int size=0;
    for(int i=head[u];i;i=nxt[i]){
        int v=to[i];
        if(v==fa) continue;
        size+=suma[v];
        dfs_a(v,u);
    }
    a[u]=suma[u]-size;
}
void init()
{
    etot=0,SUMA=0;
    memset(suma,0,sizeof(suma));
    memset(head,0,sizeof(head));
    memset(dep,0,sizeof(dep));
    memset(k,0,sizeof(k));
    memset(b,0,sizeof(b));
    memset(a,0,sizeof(a));
}
int main()
{
    freopen("single.in","r",stdin);
    freopen("single.out","w",stdout);
    int T;
    scanf("%d",&T);
    while(T--){
        init();
        int t;
        scanf("%d",&n); 
        for(int i=1;i<n;i++){
            int u,v;
            scanf("%d%d",&u,&v);
            adde(u,v),adde(v,u);
        }
        scanf("%d",&t);
        if(!t){
            for(int i=1;i<=n;i++) {
                scanf("%d",&a[i]);
                SUMA+=a[i];
            }
            dfs_t0(1,1);
            //先暴力计算b[1]
            for(int i=1;i<=n;i++) b[1]+=a[i]*dep[i];
            dfs_b(1,1);
            for(int i=1;i<=n;i++)   printf("%d ",b[i]);
            printf("\n");
        }
        if(t==1){
            for(int i=1;i<=n;i++)   scanf("%d",&b[i]);
            dfs_t1(1,1);
            long long tot=0;
            for(int i=2;i<=n;i++) tot+=k[i];
            suma[1]=SUMA=(2*b[1]+tot)/(n-1);
            for(int i=2;i<=n;i++)
            suma[i]=(SUMA-k[i])/2;
            dfs_a(1,1);
            /*1是根节点 
            sigma suma[i](i是整棵树除了根节点1以外的点的集合）=b[1] 
            可以这么理解吧——当点v又被一颗子树包含了，则说明
            它离根节点又多了一次距离 
            sigma k[i]=(n-1)SUMA-2*sigma suma[v]=tot
            sigma k[i]=(n-1)SUMA-2*b[1]=tot
            SUMA=……*/
            for(int i=1;i<=n;i++)   printf("%d ",a[i]);
            printf("\n");
        }

    }

    return 0;
}