B 蒜头君的树

时间限制 : - MS   空间限制 : - KB 

评测说明 : 2s,256m

问题描述

蒜头君有一棵有根树，树的每一边都有边权，蒜头君想知道任意两点间最短距离之和为多少。 另外，由于各种原因，蒜头君的树的边的边权会发生若干次改变，蒜头君想让你告诉他，每一 次改变后，任意两点间最短距离之和为多少？

输入格式

输出格式

r

样例输入

4
1 1
1 1
1 1
1
2 2

样例输出

9
12

【题目分析】

算法 1
每次 O(N2) 查询每两对点的距离，时间复杂度 O(N2M)，期望得分 30 分。
算法 2
考虑每条边会在答案中被计算几次，假设删除一条边后所得到的连通分量的大小为 a 和 b，
则 这条边会被统计 a*b 次，可以用一遍 DFS 得到每个点及其子节点的总数，然后可以得
到 a 和 b，对于每个询问都做一遍 DFS。时间复杂度 O(N ∗ M),期望得分 70 分。
算法 3
对于任意一条边 i， 设该边长度为 L[i]， 连的儿子节点为 x。
size[x]为 x 为根的子树中节点的总数。 那么 i 号边被公交线路经过的次数为 size[x]*(n-size[x])
i 号边对答案的贡献为 TotLen+=L[i]* size[x]*(n-size[x])
对于每个询问，只考虑修改每一条边会变成什么样，则可以 O(1) 处理每一个询问，时间复
杂度 O(N + M)，期望得分 100 分。

【参考代码】

 #include<cstdio>
 #include<cctype>
 #define ll long long
 #define maxn 100003
 using namespace std;
 int n, m, tot;
 int Last[maxn], Fa[maxn], Size[maxn], Num[maxn];
 ll ans;
 ll F[maxn];
 char buf[ << ], *p1 = buf, *p2 = buf, obuf[ << ], *O = obuf;
 struct node {
     int End, Next, Len;
 }Edge[maxn << ];
 namespace Ironclad_Programming {
     #define R register int
     #define For(i, s, n) for (R i = s; i <= n; ++ i)
     #define Getch() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1 ++)
     inline int read() {
         int x = , f = ;
         char ch = Getch();
         while(!isdigit(ch)){if (ch == '-')f = -; ch = Getch();}
         while(isdigit(ch))x = x *  + (ch ^ ), ch = Getch();
         return x * f;
     }
     inline void Add(int x, int y, int z) {
         Edge[++ tot].End = y;
         Edge[tot].Len = z;
         Edge[tot].Next = Last[x];
         Last[x] = tot;
     }
     void ini() {
         n = read();
         For (i, , n) {
             int x, y;
             x = read(), y = read();
             Add(x, i, y);
             Add(i, x, y);
             Fa[i] = x;
             Num[i] = tot;
         }
     }
     namespace solve {
         void DFS(int x) {
             ++ Size[x];
             for (R i = Last[x]; i; i = Edge[i].Next) {
                 int y = Edge[i].End;
                 if (y ^ Fa[x]) {
                     DFS(y);
                     ans += 1LL * Edge[i].Len * F[y];
                     Size[x] += Size[y];
                 }
             }
             F[x] = 1LL * Size[x] * (n - Size[x]);
         }
         void Del_Back() {
             m = read();
             For (i, , m) {
                 int x, y;
                 x = read(), y = read();;
                 ans += 1LL * (y - Edge[Num[x]].Len) * F[x];
                 Edge[Num[x]].Len = y;
                 printf("%lld\n", ans);
             }
         }
         void executive() {
             DFS();
             printf("%lld\n", ans);
             Del_Back();
         }
     }
     void Main() {
         ini();
         solve::executive();
     }
     #undef R
     #undef For
     #undef Getch
 }
 int main() {
     Ironclad_Programming::Main();
     return ;
 }