Luogu
题意：
动态维护带权重心。
sol
这是一道写起来很舒服的动态点分治。（不像某些毒瘤题）
我们考虑，如果你选择的补给点不是当前的带权重心，那么带权重心就在补给点的一个子树中（你把补给点当做根的话）。那么，你把补给点向带权重心所在的子树中移动的时候，答案一定会减小。换言之，如果补给点无论向哪个方向移动答案都不会减小，那么这个点就是带权重心。
所以我们每次考虑移动补给点然后计算即可。
但是怎么移动呢？
最优复杂度的移动策略是：先假设点分树的根就是补给，然后你一次检查与它在原树中相连的所有点，如果有一个比它小（这样的点至多有一个），这时候你不是直接跳向这个点，而是跳向点分树中的那个儿子。这样在保证了解的范围的同时也保证了复杂度，因为点分树的树高是\(\log n\)，所以最多向下跳\(\log n\)
次。
主题思想解决了，现在我们考虑怎么快速计算出以某一个点为补给点时的答案。
我们记一下三个变量（不要吐槽变量名）：
\(sum_i\)：表示点分树中以i为根的子树的权值和
\(gather_i\)：表示点分树中以i为根的子树全部集合到i的总耗费
\(tofa_i\)表示点分树中以i为根的子树全部集合到i在点分树中的父节点的总耗费
可以发现其实\(gather_u=\sum tofa_v\)，其中v是u在点分树中的儿子。之所以这样记是为了去除重复计算。
具体怎么算请自行YY。（YY有益身心健康）
总的算起来复杂度是\(O(n\log^3n)\)，如果你写\(RMQLCA\)的话就是\(O(n\log^2n)\)
code
#include<cstdio>
#include<algorithm>
using namespace std;
const int N = 100005;
#define ll long long
int gi()
{
int x=0,w=1;char ch=getchar();
while ((ch<'0'||ch>'9')&&ch!='-') ch=getchar();
if (ch=='-') w=0,ch=getchar();
while (ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
return w?x:-x;
}
int n,m,dis[N],sum[N];
ll gather[N],tofa[N];
struct edge{int to,next,w;}a[N<<1];
int head[N],cnt,pa[N],dep[N],sz[N],son[N],top[N];
void dfs1(int u,int f)
{
pa[u]=f;dep[u]=dep[f]+1;sz[u]=1;
for (int e=head[u];e;e=a[e].next)
{
int v=a[e].to;if (v==f) continue;
dis[v]=dis[u]+a[e].w;dfs1(v,u);
sz[u]+=sz[v];if (sz[v]>sz[son[u]]) son[u]=v;
}
}
void dfs2(int u,int up)
{
top[u]=up;
if (son[u]) dfs2(son[u],up);
for (int e=head[u];e;e=a[e].next)
if (a[e].to!=pa[u]&&a[e].to!=son[u])
dfs2(a[e].to,a[e].to);
}
int lca(int u,int v)
{
while (top[u]^top[v])
{
if (dep[top[u]]<dep[top[v]]) swap(u,v);
u=pa[top[u]];
}
return dep[u]<dep[v]?u:v;
}
int getdis(int u,int v){return dis[u]+dis[v]-2*dis[lca(u,v)];}
struct node{int to,next,rt;}G[N];
int vis[N],w[N],fa[N],root,tot,RT,ft[N];
void getroot(int u,int f)
{
sz[u]=1;w[u]=0;
for (int e=head[u];e;e=a[e].next)
{
int v=a[e].to;if (v==f||vis[v]) continue;
getroot(v,u);
sz[u]+=sz[v];w[u]=max(w[u],sz[v]);
}
w[u]=max(w[u],tot-sz[u]);
if (w[u]<w[root]) root=u;
}
void solve(int u,int f)
{
fa[u]=f;vis[u]=1;int pre_tot=tot;
for (int e=head[u];e;e=a[e].next)
{
int v=a[e].to;if (vis[v]) continue;
if (sz[v]>sz[u]) tot=pre_tot-sz[u];
else tot=sz[v];
root=0;
getroot(v,0);
G[++cnt]=(node){v,ft[u],root};ft[u]=cnt;
solve(root,u);
}
}
void Modify(int u,int val)
{
sum[u]+=val;
for (int i=u;fa[i];i=fa[i])
{
int dist=getdis(u,fa[i]);
sum[fa[i]]+=val;
gather[fa[i]]+=(ll)val*dist;
tofa[i]+=(ll)val*dist;
}
}
ll calc(int u)
{
ll res=gather[u];
for (int i=u;fa[i];i=fa[i])
{
int dist=getdis(u,fa[i]);
res+=(ll)(sum[fa[i]]-sum[i])*dist;
res+=gather[fa[i]]-tofa[i];
}
return res;
}
ll Query(int u)
{
ll temp=calc(u);
for (int e=ft[u];e;e=G[e].next)
if (calc(G[e].to)<temp) return Query(G[e].rt);
return temp;
}
int main()
{
n=gi();m=gi();
for (int i=1;i<n;i++)
{
int u=gi(),v=gi(),w=gi();
a[++cnt]=(edge){v,head[u],w};head[u]=cnt;
a[++cnt]=(edge){u,head[v],w};head[v]=cnt;
}
dfs1(1,0);dfs2(1,1);
w[0]=tot=n;cnt=0;
getroot(1,0);
RT=root;
solve(root,0);
while (m--)
{
int u=gi(),e=gi();
Modify(u,e);
printf("%lld\n",Query(RT));
}
return 0;
}