[bzoj4381][POI2015]Odwiedziny

4381: [POI2015]Odwiedziny

Time Limit: 20 Sec Memory Limit: 128 MB
Submit: 303 Solved: 128
[Submit][Status][Discuss]
Description

给定一棵n个点的树，树上每条边的长度都为1，第i个点的权值为a[i]。
Byteasar想要走遍这整棵树，他会按照某个1到n的全排列b走n-1次，第i次他会从b[i]点走到b[i+1]点，并且这一次的步伐大小为c[i]。
对于一次行走，假设起点为x，终点为y，步伐为k，那么Byteasar会从x开始，每步往前走k步，如果最后不足k步就能到达y，那么他会一步走到y。
请帮助Byteasar统计出每一次行走时经过的所有点的权值和。

Input

第一行包含一个正整数n(2<=n<=50000)。表示节点的个数。
第二行包含n个正整数，其中第i个数为ai，分别表示每个点的权值。
接下来n-1行，每行包含两个正整数u,v(1<=u,v<=n)，表示u与v之间有一条边。
接下来一行包含n个互不相同的正整数，其中第i个数为bi，表示行走路线。
接下来一行包含n-1个正整数，其中第i个数为ci，表示每次行走的步伐大小。

Output

包含n-1行，每行一个正整数，依次输出每次行走时经过的所有点的权值和

Sample Input

5

1 2 3 4 5

1 2

2 3

3 4

3 5

4 1 5 2 3

1 3 1 1

Sample Output

10

6

10

5

$n$的大小只有$50000$，显然可以对询问的$c$分块。
对于$c>\sqrt n$的，直接暴力向上走，复杂度是$n\sqrt n logn$
对于$c<=\sqrt n$的，$n\sqrt n$的预处理出每个点每次走$x$到根的权值和。这样对于每一个询问就用询问的起点，终点，和$lca$加加减减就行了。复杂度是$nlogn$的。
总的复杂度就是：$O(n\sqrt n +n\sqrt n logn)$

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int O=250;
const int N=50010;
struct S{int st,en;}aa[N<<1];
int n,point[N],next[N<<1],tot,v[N],bi[N],c[N],fa[N][17],o[N][O+10],deep[N],to[N][O+10],ans;
inline int in(){
    int x=0;char ch=getchar();
    while(ch<'0'||ch>'9') ch=getchar();
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return x;
}
inline void add(int x,int y){
    next[++tot]=point[x];point[x]=tot;
    aa[tot].st=x;aa[tot].en=y;
    next[++tot]=point[y];point[y]=tot;
    aa[tot].st=y;aa[tot].en=x;
}
inline void dfs(int x,int last){
    int i,now=x;
    for(i=1;i<=16;++i)
        fa[x][i]=fa[fa[x][i-1]][i-1];
    for(now=fa[x][0],i=1;i<=O&&i<=deep[x];++i,now=fa[now][0])
        to[x][i]=now;
    for(o[x][0]=v[x],i=1;i<=O;++i){
        if(x==1){
            o[x][i]=v[1];
            continue;
        }
        if(deep[x]<=i) o[x][i]=v[1]+v[x];
        else o[x][i]=o[to[x][i]][i]+v[x];
    }
    for(i=point[x];i;i=next[i])
        if(aa[i].en!=last){
            fa[aa[i].en][0]=x;
            deep[aa[i].en]=deep[x]+1;
            dfs(aa[i].en,x);
        }
}
inline int LCA(int x,int y){
    if(deep[x]<deep[y]) swap(x,y);
    int i,t=deep[x]-deep[y];
    for(i=0;i<=16;++i)
        if(t&(1<<i)) x=fa[x][i];
    for(i=16;~i;--i)
        if(fa[x][i]!=fa[y][i])
            x=fa[x][i],y=fa[y][i];
    return x==y?x:fa[x][0];
}
inline int get(int x,int t){
    int i;
    for(i=16;~i;--i)
        if(t&(1<<i)) x=fa[x][i];
    return x;
}
int main(){
    int i,x,y,z,t;
    n=in();
    for(i=1;i<=n;++i) v[i]=in();
    for(i=1;i<n;++i){
        x=in();y=in();
        add(x,y);
    }
    for(i=1;i<=n;++i) bi[i]=in();
    for(i=1;i<n;++i) c[i]=in();
    for(dfs(1,0),i=1;i<n;++i){
        x=bi[i];y=bi[i+1];ans=0;
        int lca=LCA(x,y);
        if(c[i]<=O){
            if(x==lca){
                t=deep[y]-deep[x];
                if(t%c[i]!=0) ans+=v[y],y=get(y,t%c[i]);
                ans+=(o[y][c[i]]-o[x][c[i]]+v[x]);
            }
            else if(y==lca){
                t=deep[x]-deep[y];
                if(t%c[i]!=0) ans+=v[y],y=get(x,t-t%c[i]);
                ans+=(o[x][c[i]]-o[y][c[i]]+v[y]);
            }
            else{
                t=deep[x]-deep[lca];
                z=get(x,t-t%c[i]);
                ans+=(o[x][c[i]]-o[z][c[i]]+v[z]);
                int len=c[i]-(deep[z]-deep[lca]);
                if(len>=deep[y]-deep[lca]) ans+=v[y];
                else{
                    lca=get(y,deep[y]-deep[lca]-len);
                    t=deep[y]-deep[lca];
                    if(t%c[i]!=0) ans+=v[y],y=get(y,t%c[i]);
                    ans+=(o[y][c[i]]-o[lca][c[i]]+v[lca]);
                }
            }
        }
        else{
            if(x==lca){
                while(deep[y]-deep[x]>=c[i]){
                    ans+=v[x];
                    x=get(y,deep[y]-deep[x]-c[i]);
                }
                ans+=v[x];
                if(x!=y) ans+=v[y];
            }
            else if(y==lca){
                while(deep[x]-deep[y]>=c[i]){
                    ans+=v[x];
                    x=get(x,c[i]);
                }
                ans+=v[x];
                if(x!=y) ans+=v[y];
            }
            else{
                while(deep[x]-deep[lca]>=c[i]){
                    ans+=v[x];
                    x=get(x,c[i]);
                }
                ans+=v[x];
                int len=c[i]-(deep[x]-deep[lca]);
                if(len>=deep[y]-deep[lca]) ans+=v[y];
                else{
                    lca=get(y,deep[y]-deep[lca]-len);
                    while(deep[y]-deep[lca]>=c[i]){
                        ans+=v[lca];
                        lca=get(y,deep[y]-deep[lca]-c[i]);
                    }
                    ans+=v[lca];
                    if(y!=lca) ans+=v[y];
                }
            }
        }
        printf("%d\n",ans);
    }
}