魔法水晶

魔法水晶承载着魔法师的法力，是魔法师法力的结晶。

Elsa 拥有 n 个魔法水晶。为了让这 n 个魔法水晶处于相互联系的状态中，

并且不出现流动混乱，Elsa 用 n-1 条法力流动通道将魔法水晶联系起来。每条

通道直接连接两个魔法水晶，并且每对魔法水晶都直接或间接相连。

每条法力流动通道有一个延迟量，一对魔法水晶之间的延迟量是连接它们

的路径上所有通道的延迟量之和。n 个魔法水晶这一整体的总延迟是每对魔法

水晶之间的延迟量的和。

Elsa 会进行 m 次施法操作，每次施法会将连接魔法水晶 u 和 v 的路径上所

有的法力流动通道的延迟量增加 w。

她需要你帮助她动态地计算 n 个魔法水晶这一整体的总延迟。

【输入格式】

第一行一个数 n，接下来 n-1 行，每行三个数 a、b、c，表示有一条连接

a、b 的延迟量为 c 的法力流动通道。

接下来一个数 m，表示施法次数。接下来 m 行，每行三个数 u、v、w，表示

连接 u 和 v 的路径上的每一条法力流动通道的延迟量都增加 w。

【输出格式】

输出 m+1 行，第 i 行输出一个整数表示完成前(i-1)次施法操作后的总延

迟。

答案对 1,000,000,007 取模。

【样例输入】

3

1 2 2

1 3 1

2

1 2 -2

2 3 1

【样例输出】

6

2

6

【数据规模与约定】

20%的数据，n,m≤50

40%的数据，n,m≤300

60%的数据，n,m≤3000

另 20%的数据，m=0

100%的数据，n,m≤100000，-10^9≤c,w≤10^9

每条边的贡献单独计算。=左侧节点数×右侧节点数×边权

若一条边两侧分别有a个点和b个点，那么这条边会出现在ab个点

对中。

这样就可以计算距离和了。

修改，可以先求出路径上每条边的ab和，再乘上变化量，就是距离

和的变化量了。

倍增优化。

#include

#include

#include

#define LL long long

using namespace std;

int next[200003],point[100003];//next数组存储，next的下标表示边的编号，存的是以该边的起点为起点的上一条边的编号；point的下标是点的编号，存的是以该点为起点的最后一条边的编号

LL val[200003],c;//val的下标是边的编号，存储边的权值

int behind[200003];//behind的下标是边的编号，存的是边的终点

int f[100003][20],h[100003],size[100003];//f的第一维表示当前节点号，第二维表示向上2^i条边，存储所到达的节点号；h表示节点深度；size表示一侧子树的节点数

LL lensum[100003][20];//lensum的第一维表示当前节点号，第二维表示向上2^i条边

存储所经过的所有边的贡献之和（不乘边权，只计算经过的次数即左侧的节点数乘右侧的节点数）

long long  n,m,ans,i,j,a,b;

int mi[20],p;

void add(int x,int y,long long v,int num)//next数组双向存储

{

behind[num]=y;

next[num]=point[x];

point[x]=num;

val[num]=v;

}

void dfs(int x,int ahead)

{

size[x]=1;

int now=point[x];

while (now)//枚举与当前节点直接相连的节点

 {

  if (behind[now]!=ahead)

    {

     dfs(behind[now],x);//递归计算子树节点数

   size[x]+=size[behind[now]];该点一侧的节点数等于他所有子树的节点数相加

   ans=(ans+(LL)size[behind[now]]%p*(LL)(n-size[behind[now]])%p*val[now])%p; //答案加上当前点到与他直接相连的节点的边的贡献

    }

  now=next[now];

 }

}

void build (int x,int ahead,int dep)//构造倍增，向上2^0,2^1,2^2,2^3……

{

h[x]=dep;

for (int i=1;i<16;i++)

 {

  if (h[x]-mi[i]<0) break;

  f[x][i]=f[f[x][i-1]][i-1];向上2^i相当于向上2^i-1到达某个点再由这个点向上2^i-1

  lensum[x][i]=(lensum[x][i-1]+lensum[f[x][i-1]][i-1])%p;

 }

int now=point[x];

while (now)

  {

   if (behind[now]!=ahead)//即将遍历的点不是来的时候经过的点

     {

     f[behind[now]][0]=x;//与x的后继节点相距2的0次方即1的节点是x本身     

    lensum[behind[now]][0]=(LL)size[behind[now]]*(LL)(n-size[behind[now]])%p；

     build(behind[now],x,dep+1);

     }

   now=next[now];

  }

}

long long  lca(int x,int y)//求x,y到他们的最近公共祖先需要经过的边数的贡献值总和

{

if (h[x]

 swap(x,y);

int depcha=h[x]-h[y];

long long sum=0;

for (int i=0;i<17;i++)//使X,Y先走到同一深度

 if (depcha>>i&1)//右移i位判断最后一位是否为1，既判段是否可以减去2^i，将他分成几个2的几次方相加（2 在二进制下为10，4在二进制下为100，8在二进制下为1000，所以差值可以按位分解，若为1则减去2^i,直到减到0为止）

   {

   sum=(sum+lensum[x][i])%p;

   x=f[x][i];//向上2^i到达的节点

   }

if (x==y)

 return sum;

for (int i=16;i>=0;i--)

 if (f[x][i]!=f[y][i])//从大到小保证不会跳过最近公共祖先

   {

    sum=(sum+lensum[x][i]+lensum[y][i])%p;

    x=f[x][i];

    y=f[y][i];

   }

sum=(sum+lensum[x][0]+lensum[y][0])%p;

return sum; 

}

int main()

{

 freopen("sum.in","r",stdin);

 freopen("sum.out","w",stdout);

 scanf("%d",&n);

 mi[0]=1;

 p=1000000007;

 for (i=1;i<17;i++)

   mi[i]=mi[i-1]*2;

 for (i=1;i<=n-1;i++)

   {

     scanf("%d%d%I64d",&a,&b,&c);

     if (c<0)

      c+=p;

     add(a,b,c,i*2);

     add(b,a,c,i*2+1);

   }

 dfs(1,0);

 printf("%I64d\n",ans);

 build(1,0,1);

 scanf("%d",&m);

 for (i=1;i<=m;i++)

   {

     scanf("%d%d%I64d",&a,&b,&c);

     c=(c+p)%p;

     int k=lca(a,b);//k即为a,b之间所有边经过的次数之和

     ans=(ans+c*k)%p;

 printf("%I64d\n",ans);  

   }

 return 0;

}