BZOJ4381 POI2015 Odwiedziny

---

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

• Line 1：一个正整数n(2<=n<=50000)。表示节点的个数。
• Line 2：n个正整数，其中第i个数为$a_i(1\le a_i\le 10000)$，分别表示每个点的权值。
• Line 3~n+1：包含两个正整数$u,v(1\le u,v\le n)$，表示u与v之间有一条边。
• Line n+2：n个互不相同的正整数，其中第i个数为$b[i](1\le b[i]\le n)$，表示行走路线。
• Line n+3：n-1个正整数，其中第i个数为$c_i(1\le c_i<n)$，表示每次行走的步伐大小。

Ouput

包含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

---

在树上的路径求值问题，一般需要预处理出两种数据：

• lca（将<$u,v$>转化为求<$u,lca$>和<$v,lca$>路径上的权值和）
• dis_root[u]（表示当前点$u$到根节点路径上的权值和）

于是我们对于询问的两点<$u,v$>，有以下暴力算法：

• 将<$u,lca,v$>拉成一条链，此时不一定能直接跳到lca或者v，那么在接下来处理的时候，对于两者进行特别讨论。每次跳step步的时候通过倍增父亲数组进行$O(logn)$跳跃。

for(int i=1;i<n;st=nxt[i],i++){
    int u=st,v=nxt[i],lca=Lca(u,v),sum=0;
    sum+=val[u];
    while(dep[u]-dep[lca]>=stp[i]){
        up(u,stp[i]);
        sum+=val[u];
    }
    int step=stp[i]-(dep[u]-dep[lca]);//lca往下找step次的节点结束
    if(dep[lca]+step>dep[v]){
        Pf(sum);
        continue;
    }
    int p=(dep[v]-(dep[lca]+step))%stp[i];
    up(v,p);
    if(v!=lca)sum+=val[v];
    while(dep[v]-dep[lca]>=stp[i]){
        up(v,stp[i]);
        if(v!=lca)sum+=val[v];
    }
    Pf(sum);
}

这样大概能过60%的数据（POI只能过30%的整体分）。

观察上述暴力算法，我们发现复杂度过高是由于附加了倍增的$O(logn)$，当step较大时倍增的复杂度不够明显可以继续暴力，而step较小时倍增附带的复杂度就非常明显了。根据这句话，我们联想到BSGS算法：

• 当step较小时，我们可以直接$O(1)$跳到目标父亲$fa[step][u]$上，并且对于当前点，我们还可以直接处理出$\sum_{k=0}dis_{root}[fa[k*step][u]]$。于是在baby_step部分可以$O(1)$得到，而giant_step部分的复杂度也不会很高。

剩下的部分就非常好实现了。

#include <bits/stdc++.h>
using namespace std;
const int M=50005,S=20,T=200;
inline void Rd(int &res){
    res=0;char c;
    while(c=getchar(),c<48);
    do res=(res<<3)+(res<<1)+(c^48);
    while(c=getchar(),c>47);
}
inline void Pn(int res){
    if(!res)return;
    Pn(res/10);
    putchar(res%10^48);
}
inline void Pf(int res){
    if(!res)putchar('0');
    Pn(res);
    putchar('\n');
}
int val[M];
int st,nxt[M],stp[M];
/*---------------------------------------*/
struct edge{int v,nxt;}Edges[M<<1];int head[M];
void add_edge(int u,int v,int &top){
    Edges[++top]=(edge){v,head[u]};head[u]=top;
    Edges[++top]=(edge){u,head[v]};head[v]=top;
}
int fa[S][M],dep[M];
int jump[T][M],root[T][M];
void dfs_lca(int u,int pre,int d){
    dep[u]=d,fa[0][u]=pre;
    for(int j=head[u];~j;j=Edges[j].nxt)
        if(Edges[j].v!=pre)dfs_lca(Edges[j].v,u,d+1);
}
void dfs_calc(int u,int pre){
    for(int step=1;step<T;step++)// update root array
        root[step][u]=root[step][jump[step][u]]+val[u];
    for(int j=head[u];~j;j=Edges[j].nxt)
        if(Edges[j].v!=pre)dfs_calc(Edges[j].v,u);
}
void init_lca(int n){
    dfs_lca(1,0,1);
    for(int k=0;k+1<S;k++)// update fa array
        for(int i=1;i<=n;i++)
            fa[k+1][i]=fa[k][fa[k][i]];

    for(int i=1;i<=n;i++)jump[1][i]=fa[0][i];// update jump array
    for(int k=1;k+1<T;k++)
        for(int i=1;i<=n;i++)
            jump[k+1][i]=fa[0][jump[k][i]];

    dfs_calc(1,0);
}
void up(int &u,int step){
    for(int k=0;step>>k;k++)
        if(step>>k&1)u=fa[k][u];
}
int Lca(int u,int v){
    if(dep[u]<dep[v])swap(u,v);
    up(u,dep[u]-dep[v]);
    if(u==v)return u;
    for(int k=S-1;~k;k--)
        if(fa[k][u]!=fa[k][v])
            u=fa[k][u],v=fa[k][v];
    return fa[0][u];
}
/*---------------------------------------*/
int giant_step(int u,int v,int stp){
    int lca=Lca(u,v);
    int lenx=dep[u]-dep[lca];
    int leny=dep[v]-dep[lca]+lenx;
    if(leny%stp){//即不能一次性地从u跳到v 
        if(leny%stp>dep[v]-dep[lca]){//右侧无法进行跳跃 
            int p=stp-(lenx+stp-1)%stp+1;
            return root[stp][u]-root[stp][p];
        }
        up(v,leny%stp);
    }
    leny=dep[v]-dep[lca];
    //现在左右两侧是刚好可以跳到的。 
    if(lenx%stp==0)
        return root[stp][u]+root[stp][v]-root[stp][lca]-root[stp][jump[stp][lca]];
    else
        return root[stp][u]+root[stp][v]-root[stp][jump[stp-lenx%stp][lca]]-root[stp][jump[stp-leny%stp][lca]];
}
int baby_step(int u,int v,int stp){
    int lca=Lca(u,v),sum=0;
    sum+=val[u];
    while(dep[u]-dep[lca]>=stp){
        up(u,stp);
        sum+=val[u];
    }
    int step=stp-(dep[u]-dep[lca]);//lca往下找step次的节点结束
    if(dep[lca]+step>dep[v])return sum;
    int p=(dep[v]-(dep[lca]+step))%stp;
    up(v,p);
    if(v!=lca)sum+=val[v];
    while(dep[v]-dep[lca]>=stp){
        up(v,stp);
        if(v!=lca)sum+=val[v];
    }
    return sum;
}
/*---------------------------------------*/

int main(){
    int n;Rd(n);
    for(int i=1;i<=n;i++)Rd(val[i]);
    memset(head,-1,sizeof(head));
    int top=0;
    for(int i=1,u,v;i<n;i++){
        Rd(u),Rd(v);
        add_edge(u,v,top);
    }
    init_lca(n);
    Rd(st);
    for(int i=1;i<n;i++)Rd(nxt[i]);
    for(int i=1;i<n;i++){
        Rd(stp[i]);
        Pf(stp[i]<T?giant_step(st,nxt[i],stp[i]):baby_step(st,nxt[i],stp[i]));
        st=nxt[i];
    }
    return 0;
}