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=;
     struct edge{ int to,next,w; }E[maxn<<];
     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<<],rc[maxn<<],mx[maxn<<],flag[maxn<<],tot;
     LL g[maxn<<],sum;
     segment_tree(){ sum=np=np2=rt=; }
     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]=,sz[i]=;
         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>>;
         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+]]==a[m+]) g[rc[now]]+=1ll*flag[now]*(dist[a[R]]-dist[a[m+]]);
         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]=;
     }
     void build(int &now,int L,int R){
         now=++np2,lc[now]=rc[now]=;
         g[now]=mx[now]=flag[now]=;
         if(L==R) return;
         int m=L+R>>;
         build(lc[now],L,m); build(rc[now],m+,R);
     }
     int query_p(int now,int L,int R){
         if(L==R) return a[L];
         pushdown(now,L,R);
         int m=L+R>>;
         if(mx[rc[now]]*>tot) return query_p(rc[now],m+,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]=;
             return;
         }
         pushdown(now,L,R);
         int m=L+R>>;
         if(pos<=m) query(lc[now],L,m,pos);
         else query(rc[now],m+,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>>;
         if(B<=m) return query_g(lc[now],L,m,A,B);
         if(A>m) return query_g(rc[now],m+,R,A,B);
         return query_g(lc[now],L,m,A,B)+query_g(rc[now],m+,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>>;
         if(B<=m) update1(lc[now],L,m,A,B,delt);
         else if(A>m) update1(rc[now],m+,R,A,B,delt);
         else update1(lc[now],L,m,A,B,delt),update1(rc[now],m+,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]=;
             if(top[a[L]]!=a[L]) g[now]+=1ll*delt*dist[fa[a[L]]];
             return;
         }
         pushdown(now,L,R);
         int m=L+R>>;
         if(pos<=m) update2(lc[now],L,m,pos,delt);
         else update2(rc[now],m+,R,pos,delt);
         pushup(now);
     }
     void update(int p,int delt){
         tot+=delt,sum+=1ll*delt*dist[p];
         while(p){
             update1(rt,,n,l[top[p]],l[p],delt);
             if(son[p]) update2(rt,,n,l[son[p]],delt);
             p=fa[top[p]];
         }
     }
     LL ans(){
         int p=query_p(rt,,n);
         query(rt,,n,l[p]);
         LL re=sum+1ll*dist[p]*(tot-sz[p]);
         while(p){
             re-=query_g(rt,,n,l[top[p]],l[p]);
             p=top[p];
             query(rt,,n,l[p]); query(rt,,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=,nega=;
     char ch=getchar();
     while((ch<''||ch>'')&&ch!='-') ch=getchar();
     if(ch=='-') nega=,ch=getchar();
     while(ch>=''&&ch<='') x=x*+ch-'',ch=getchar();
     if(nega) x=-x;
 }
 int out_cnt,out[];
 void _printf(LL x)
 {
     out[++out_cnt]=x%,x/=;
     while(x) out[++out_cnt]=x%,x/=;
     while(out_cnt) putchar(''+out[out_cnt--]);
     putchar('\n');
 }
 void data_in()
 {
     _scanf(N);_scanf(Q); st.n=N;
     int x,y,z;
     for(int i=;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(,,);
     st.DFS2(,,);
     st.build(st.rt,,st.n);
     for(int i=;i<=Q;i++){
         _scanf(u);_scanf(e);
         st.update(u,e);
         _printf(st.ans());
     }
 }
 int main()
 {
     data_in();
     work();
     return ;
 }