BZOJ 3924 ZJOI2015 幻想乡战略游戏 树链剖分

题目链接：https://www.luogu.org/problemnew/show/P3345(bzoj权限题)

题意概述：动态维护树的上所有点到这棵树的带权重心的距离和。N,Q<=100000.

分析：

　　首先考虑一个性质，对于任意一个点i来说，如果存在一个儿子j使得sz[j]*2>tot，那么i一定不是树的重心，并且重心应该在j的子树中，否则重心就可以是i。（这里必须是事先积累的知识，证明简单，略）

　　于是就可以考虑一个暴力辣！每次从根出发按照上面的条件进行查找，一旦发现一个点没有儿子满足上面的性质，那么这个点就应该是一个重心。

　　但是这样一次次走很慢。注意到我们找的是深度最大的j满足sz[j]*2>tot(满足条件的j一定在一条链上面)，这里有很多的做法，但是考虑到我们计算答案的时候可能用到树剖，所以我们选择在DFS序上面操作，维护区间的sz最大值，直接在线段树上来二分查找，一次查找当前重心的复杂度是O(logn)。

　　关于答案的计算，我们发现对于点i为重心的时候，其答案分成两部分，一个是i的子树，一个是i的祖先。我们单独计算每个祖先不包含i的其余子树的贡献，全部加起来就是这次的答案。

　　通过计算，一次的答案可以表示为：

　　  sum[1]+d[i]*(tot-sz[i])-sum{ f(j) | j为i到1路径上的节(包括i)） }

　　  f(i)=sz[i]*(d[i]-d[fa[i]])+(sz[fa[i]]-sz[i])*d[fa[i]]

　　  sum[i]表示i的子树中的点到i的带权距离和，sz[i]表示i的子树中所有点的权值和，d[i]表示i到1的路径长度，tot表示所有点的权值和。

　　维护：树剖，维护所有的sz和f以及sz的最大值，重链顶端的点不要去维护，每一次跳到的时候单独计算其f（因为没有办法同时维护一个点所有的儿子的f）。每次修改一个点的权值之后，其到1路径上所有点的sz都会改变，我们发现这些点的f值会发生变化，同时在更新中我们到达的所有的点的重儿子的f也会发生变化，记得更新一下。

　　时间复杂度O(N+Q*logN^2)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<set>
#include<map>
#include<vector>
#include<cctype>
using namespace std;
typedef long long LL;

int N,Q;
struct segment_tree{
    static const int maxn=100005;
    struct edge{ int to,next,w; }E[maxn<<1];
    int first[maxn],np,n,dist[maxn],_sz[maxn],fa[maxn],son[maxn],top[maxn];
    int dfs_clock,l[maxn],a[maxn],sz[maxn];
    int rt,np2,lc[maxn<<1],rc[maxn<<1],mx[maxn<<1],flag[maxn<<1],tot;
    LL g[maxn<<1],sum;
    segment_tree(){ sum=np=np2=rt=0; }
    void add_edge(int u,int v,int w){
        E[++np]=(edge){v,first[u],w};
        first[u]=np;
    }
    void DFS1(int i,int f,int l){
        fa[i]=f,dist[i]=l;
        _sz[i]=1,sz[i]=0;
        for(int p=first[i];p;p=E[p].next){
            int j=E[p].to;
            if(j==f) continue;
            DFS1(j,i,l+E[p].w);
            _sz[i]+=_sz[j];
            if(_sz[j]>_sz[son[i]]) son[i]=j;
        }
    }
    void DFS2(int i,int f,int tp){
        top[i]=tp,l[i]=++dfs_clock;
        a[dfs_clock]=i;
        if(son[i]) DFS2(son[i],i,tp);
        for(int p=first[i];p;p=E[p].next){
            int j=E[p].to;
            if(j==f||j==son[i]) continue;
            DFS2(j,i,j);
        }
    }
    void pushup(int now){
        mx[now]=max(mx[lc[now]],mx[rc[now]]);
        g[now]=g[lc[now]]+g[rc[now]];
    }
    void pushdown(int now,int L,int R){
        if(!flag[now]) return;
        int m=L+R>>1;
        if(top[a[L]]==a[L]) g[lc[now]]+=1ll*flag[now]*(dist[a[m]]-dist[a[L]]);
        else g[lc[now]]+=1ll*flag[now]*(dist[a[m]]-dist[fa[a[L]]]);
        if(top[a[m+1]]==a[m+1]) g[rc[now]]+=1ll*flag[now]*(dist[a[R]]-dist[a[m+1]]);
        else g[rc[now]]+=1ll*flag[now]*(dist[a[R]]-dist[a[m]]);
        mx[lc[now]]+=flag[now],mx[rc[now]]+=flag[now];
        flag[lc[now]]+=flag[now],flag[rc[now]]+=flag[now];
        flag[now]=0;
    }
    void build(int &now,int L,int R){
        now=++np2,lc[now]=rc[now]=0;
        g[now]=mx[now]=flag[now]=0;
        if(L==R) return;
        int m=L+R>>1;
        build(lc[now],L,m); build(rc[now],m+1,R);
    }
    int query_p(int now,int L,int R){
        if(L==R) return a[L];
        pushdown(now,L,R);
        int m=L+R>>1;
        if(mx[rc[now]]*2>tot) return query_p(rc[now],m+1,R);
        return query_p(lc[now],L,m);
    }
    void query(int now,int L,int R,int pos){
        if(L==R){
            sz[a[L]]+=flag[now],flag[now]=0;
            return;
        }
        pushdown(now,L,R);
        int m=L+R>>1;
        if(pos<=m) query(lc[now],L,m,pos);
        else query(rc[now],m+1,R,pos);
    }
    LL query_g(int now,int L,int R,int A,int B){
        if(A<=L&&R<=B) return g[now];
        pushdown(now,L,R);
        int m=L+R>>1;
        if(B<=m) return query_g(lc[now],L,m,A,B);
        if(A>m) return query_g(rc[now],m+1,R,A,B);
        return query_g(lc[now],L,m,A,B)+query_g(rc[now],m+1,R,A,B);
    }
    void update1(int now,int L,int R,int A,int B,int delt){
        if(A<=L&&R<=B){
            mx[now]+=delt,flag[now]+=delt;
            if(top[a[L]]==a[L]) g[now]+=1ll*delt*(dist[a[R]]-dist[a[L]]);
            else g[now]+=1ll*delt*(dist[a[R]]-dist[fa[a[L]]]);
            return;
        }
        pushdown(now,L,R);
        int m=L+R>>1;
        if(B<=m) update1(lc[now],L,m,A,B,delt);
        else if(A>m) update1(rc[now],m+1,R,A,B,delt);
        else update1(lc[now],L,m,A,B,delt),update1(rc[now],m+1,R,A,B,delt);
        pushup(now);
    }
    void update2(int now,int L,int R,int pos,int delt){
        if(L==R){
            sz[a[L]]+=flag[now],flag[now]=0;
            if(top[a[L]]!=a[L]) g[now]+=1ll*delt*dist[fa[a[L]]];
            return;
        }
        pushdown(now,L,R);
        int m=L+R>>1;
        if(pos<=m) update2(lc[now],L,m,pos,delt);
        else update2(rc[now],m+1,R,pos,delt);
        pushup(now);
    }
    void update(int p,int delt){
        tot+=delt,sum+=1ll*delt*dist[p];
        while(p){
            update1(rt,1,n,l[top[p]],l[p],delt);
            if(son[p]) update2(rt,1,n,l[son[p]],delt);
            p=fa[top[p]];
        }
    }
    LL ans(){
        int p=query_p(rt,1,n);
        query(rt,1,n,l[p]);
        LL re=sum+1ll*dist[p]*(tot-sz[p]);
        while(p){
            re-=query_g(rt,1,n,l[top[p]],l[p]);
            p=top[p];
            query(rt,1,n,l[p]); query(rt,1,n,l[fa[p]]);
            re-=1ll*sz[p]*(dist[p]-dist[fa[p]])+1ll*(sz[fa[p]]-sz[p])*dist[fa[p]];
            p=fa[p];
        }
        return re;
    }
}st;

bool nega;
void _scanf(int &x)
{
    x=0,nega=0;
    char ch=getchar();
    while((ch<'0'||ch>'9')&&ch!='-') ch=getchar();
    if(ch=='-') nega=1,ch=getchar();
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    if(nega) x=-x;
}
int out_cnt,out[20];
void _printf(LL x)
{
    out[++out_cnt]=x%10,x/=10;
    while(x) out[++out_cnt]=x%10,x/=10;
    while(out_cnt) putchar('0'+out[out_cnt--]);
    putchar('
');
}
void data_in()
{
    _scanf(N);_scanf(Q); st.n=N;
    int x,y,z;
    for(int i=1;i<N;i++){
        _scanf(x);_scanf(y);_scanf(z);
        st.add_edge(x,y,z); st.add_edge(y,x,z);
    }
}
void work()
{
    int u,e;
    st.DFS1(1,0,0);
    st.DFS2(1,0,1);
    st.build(st.rt,1,st.n);
    for(int i=1;i<=Q;i++){
        _scanf(u);_scanf(e);
        st.update(u,e);
        _printf(st.ans());
    }
}
int main()
{
    data_in();
    work();
    return 0;
}