bzoj3924 幻想乡战略游戏

一开始，naive地以为只要重心向下找，然后暴力往上搞就行了，但是写加调1，2个小时wa了几遍后才发现这个找的做法是错误的。然后想了很久没收获，％了一发别人的程序，看了不久就看懂了。就是说我们知道第一次从根节点进入一个重心的时候一定是找到num值最大且满足大于总结点数一半的儿子，但是这个结论只对第一次成立！所以我们想办法将进入一次后，其他子树的信息结合到进入的子树中，然后记录下修改信息，最后反着做修改就可以复原。这样差不多等于把进入的重心看做一个新的根节点，因为我们已经把之前的信息合并到了子树中，所以那个结论我们又可以使用了！

/**************************************************************
    Problem: 3924
    User: Clare
    Language: C++
    Result: Accepted
    Time:28676 ms
    Memory:41828 kb
****************************************************************/
 
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <queue>
#include <vector>
using namespace std;
 
#define N 100010
#define INF 0x3f3f3f3f
 
int n,Sum,root,Q,New_root;
struct Edge{
    int to,value,next;
}edge[N*2],edge1[N*2*10];
int head[N],head1[N],tot,tot1;
int size[N],f[N],dis[N];
bool done[N];
long long num[N],sum[N],S_num[N],S_sum[N],total,Ans;
struct Data{
    int to;
    long long Enter_pos,value;
};
vector<Data> g[N];
 
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch<='9'&&ch>='0'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
 
void Addedge1(int u,int v,int w)
{
    tot1++;edge1[tot1].next=head1[u];edge1[tot1].to=v;edge1[tot1].value=w;head1[u]=tot1;
}
 
void Addedge(int u,int v,int w)
{
    tot++;edge[tot].next=head[u];edge[tot].to=v;edge[tot].value=w;head[u]=tot;
    tot++;edge[tot].next=head[v];edge[tot].to=u;edge[tot].value=w;head[v]=tot;
}
 
void Get_root(int k,int fa)
{
    size[k]=1;f[k]=0;
    for(int i=head[k];i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(v==fa||done[v])
            continue;
        Get_root(v,k);
        size[k]+=size[v];
        f[k]=max(f[k],size[v]);
    }
    f[k]=max(f[k],Sum-f[k]);
    if(f[k]<f[root])
        root=k;
}
 
void DFS(int k,int fa,int rt,int d)
{
    Addedge1(k,rt,d);
    for(int i=head[k];i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(v==fa||done[v])
            continue;
        DFS(v,k,rt,d+edge[i].value);
    }
}
 
void Rebuild(int k)
{
    done[k]=true;dis[k]=0;
    DFS(k,0,k,0);
    for(int i=head[k];i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(done[v])
            continue;
        root=0;Sum=size[v];
        Get_root(v,root);
        g[k].push_back((Data){root,v,edge[i].value});
        Rebuild(root);
    }
}
 
void Change(int k,long long val,long long extra)
{
    int last=0;
    for(int i=head1[k];i;i=edge1[i].next)
    {
        int v=edge1[i].to;
        num[v]+=val;sum[v]+=(long long)edge1[i].value*val+extra;
        if(v==k)
        {
            last=v;continue;
        }
        S_num[last]+=val;S_sum[last]+=(long long)edge1[i].value*val+extra;
        last=v;
    }
}
 
vector<Data> Record;
void Query()
{
    int x=New_root,Max=0;
    Record.clear();
    while(x)
    {
        Max=0;
        for(int i=1;i<g[x].size();i++)
            if(num[g[x][i].to]>num[g[x][Max].to])
                Max=i;
        if(g[x].size()==0||num[g[x][Max].to]*2<=num[x])
        {
            Ans=sum[x];
            for(int i=0;i<Record.size();i++)
                Change(Record[i].to,Record[i].Enter_pos,Record[i].value);
            printf("%lld\n",Ans);
            return;
        }
        int v=g[x][Max].to;
        Record.push_back((Data){(int)g[x][Max].Enter_pos,num[v]-num[x],-(sum[x]-S_sum[v]+(num[x]-S_num[v])*g[x][Max].value)});
        Change((int)g[x][Max].Enter_pos,num[x]-num[v],sum[x]-S_sum[v]+(num[x]-S_num[v])*g[x][Max].value);
        x=v;
    }
}
 
int main()
{
    n=read();Q=read();
    for(int i=1;i<=n-1;i++)
    {
        int x=read(),y=read(),z=read();
        Addedge(x,y,z);
    }
    root=0;f[0]=INF;Sum=n;
    Get_root(1,root);New_root=root;
    Rebuild(root);
    while(Q--)
    {
        int x=read(),y=read();
        Change(x,(long long)y,0);total+=y;
        Query();
    }
    return 0;
}