Luogu3676 小清新数据结构题 动态点分治

传送门

---

换根类型的统计问题动态点分治都是很好做的。

设所有点的点权和为$sum$

首先，我们先不考虑求$\sum\limits_i s_i^2$，先考虑如何在换根的情况下求$\sum\limits_i s_i$。

考虑一个点$i$会被统计多少次，显然是$dep_i+1$，那么$\sum\limits_i s_i = \sum\limits_i (dep_i+1) \times val_i = \sum\limits_i dep_i \times val_i + sum$。

$\sum\limits_i dep_i \times val_i$是不是似曾相识……其实就是幻想乡战略游戏

接着我们考虑这个烦人的平方项。那么我们还需要推一个结论：换根不会影响$W=\sum\limits_i s_i \times (sum - s_i)$的值。

证明如下：

我们考虑$K = \sum\limits_i \sum\limits_j val_i \times val_j \times dis(i,j)$，意思就是取两个点，将中间的所有边设为两边的点的权值之积然后相加。显然这一个值是不会因为根的变化而改变的。

接着我们考虑一条边$(x,y)$对$K$的贡献，显然是这条边分割开来的两个子树的权值和的乘积，而无论根是哪一个，这两个子树中必定有且仅有一个是树的一个子树，假设$x$对应的树是子树，它就代表着$s_x \times (sum - s_x)$，把所有边的贡献加起来就是$W=\sum\limits_i s_i \times (sum - s_i)=\sum\limits_i \sum\limits_j val_i \times val_j \times dis(i,j)$，所以$W$是不会因为根的变化而变化的。

而$W=\sum\limits_i s_i \times (sum - s_i) = sum \times \sum\limits_i s_i - \sum\limits_i s_i^2$，那么$\sum\limits_i s_i^2 = sum \times \sum\limits_i s_i - W$

接着我们考虑修改点权对$W$的影响。由$\Delta W = \Delta v \times \sum\limits_j val_j \times dep_j$，实质跟上面计算$\sum\limits_i s_i$的方法一样。

 #include<bits/stdc++.h>
 #define int long long
 //This code is written by Itst
 using namespace std;

 inline int read(){
     ;
     ;
     char c = getchar();
     while(c != EOF && !isdigit(c)){
         if(c == '-')
             f = ;
         c = getchar();
     }
     while(c != EOF && isdigit(c)){
         a = (a << ) + (a << ) + (c ^ ');
         c = getchar();
     }
     return f ? -a : a;
 }

 ;
 struct Edge{
     int end , upEd;
 }Ed[MAXN << ];
 ] , dis[MAXN][] , dep[MAXN];
 ][MAXN << ] , fir[MAXN] , logg2[MAXN << ] , size[MAXN] , cur[MAXN] , up[MAXN] , sum[MAXN];
 int cntEd , N , M , minSize , nowSize , minInd , cntST , W , allV;
 bool vis[MAXN];

 inline void addEd(int a , int b){
     Ed[++cntEd].end = b;
     Ed[cntEd].upEd = head[a];
     head[a] = cntEd;
 }

 void init_dfs(int x , int p){
     dep[x] = dep[p] + ;
     fir[x] = ++cntST;
     sum[x] = val[x];
     ST[][cntST] = x;
     for(int i = head[x] ; i ; i = Ed[i].upEd)
         if(Ed[i].end != p){
             init_dfs(Ed[i].end , x);
             ST[][++cntST] = x;
             sum[x] += sum[Ed[i].end];
         }
     W += sum[x] * (allV - sum[x]);
 }

 inline int cmp(int a , int b){
     return dep[a] < dep[b] ? a : b;
 }

 void init_st(){
      ; i <= cntST ; ++i)
         logg2[i] = logg2[i >> ] + ;
      ;  << i <= cntST ; ++i)
          ; j + ( << i) -  <= cntST ; ++j)
             ST[i][j] = cmp(ST[i - ][j] , ST[i - ][j + ( << (i - ))]);
 }

 inline int LCA(int x , int y){
     x = fir[x];
     y = fir[y];
     if(x > y)
         swap(x , y);
     ];
      << t) + ]);
 }

 inline int calcLen(int x , int y){
     );
 }

 void getSize(int x){
     vis[x] = ;
     ++nowSize;
     for(int i = head[x] ; i ; i = Ed[i].upEd)
         if(!vis[Ed[i].end])
             getSize(Ed[i].end);
     vis[x] = ;
 }

 void getRoot(int x){
     vis[x] = size[x] = ;
     ;
     for(int i = head[x] ; i ; i = Ed[i].upEd)
         if(!vis[Ed[i].end]){
             getRoot(Ed[i].end);
             maxN = max(maxN , size[Ed[i].end]);
             size[x] += size[Ed[i].end];
         }
     maxN = max(maxN , nowSize - size[x]);
     if(maxN < minSize){
         minSize = maxN;
         minInd = x;
     }
     vis[x] = ;
 }

 void init_dfz(int x , int p){
     nowSize = ;
     minSize = 0x7fffffff;
     getSize(x);
     getRoot(x);
     x = minInd;
     fa[x][] = x;
     fa[x][] = p;
     vis[x] = ;
     sum[x] = val[x];
      ; fa[x][i] ; ++i){
         fa[x][i + ] = fa[fa[x][i]][];
         dis[x][i] = calcLen(fa[x][i] , x);
         up[fa[x][i - ]] += dis[x][i] * val[x];
         sum[fa[x][i]] += val[x];
         cur[fa[x][i]] += dis[x][i] * val[x];
     }
     for(int i = head[x] ; i ; i = Ed[i].upEd)
         if(!vis[Ed[i].end])
             init_dfz(Ed[i].end , x);
 }

 void init(){
     init_dfs( , );
     init_st();
     init_dfz( , );
 }

 inline int query(int x){
     int all = cur[x];
      ; fa[x][i] ; ++i){
         all += cur[fa[x][i]] - up[fa[x][i - ]];
         all += (sum[fa[x][i]] - sum[fa[x][i - ]]) * dis[x][i];
     }
     return all;
 }

 inline void modify(int x , int v){
     W += (v - val[x]) * query(x);
     allV += v - val[x];
     sum[x] += v - val[x];
      ; fa[x][i] ; ++i){
         up[fa[x][i - ]] += (v - val[x]) * dis[x][i];
         cur[fa[x][i]] += (v - val[x]) * dis[x][i];
         sum[fa[x][i]] += v - val[x];
     }
     val[x] = v;
 }

 signed main(){
 #ifndef ONLINE_JUDGE
     freopen("3676.in" , "r" , stdin);
     freopen("3676.out" , "w" , stdout);
 #endif
     N = read();
     M = read();
      ; i < N ; ++i){
         int a = read() , b = read();
         addEd(a , b);
         addEd(b , a);
     }
      ; i <= N ; ++i){
         val[i] = read();
         allV += val[i];
     }
     init();
      ; i <= M ; ++i)
         ){
             int x = read() , y = read();
             modify(x , y);
         }
         else
             cout << allV * (query(read()) + allV) - W << '\n';
     ;
 }