BZOJ 3924: [Zjoi2015]幻想乡战略游戏

题意：动态维护支持修改点权的树上带权重心

Sol:

看见东方就点进来了233

膜拜下陈老师出的题

首先考虑如何求一个点到树上其他点的带权距离和，动态点分治可以做到单次O(logn)

现在考虑暴力，发现如果求出了每个点到其他点的带权距离和记为权值，那么以带权重心为根，权值从上到下递增，换句话说对于任何一条链，权值都是单峰的。

暴力做法可以随便选一个点枚举出边，计算出边指向的点的权值的最小值，如果最小值比当前权值大说明当前点是带权重心，否则走向权值最小的点。

发现这个做法可以用动态点分治优化，每次确定走向实质是确定了答案所在子树，在点分治重构树上从根向下跳即可；

由于重构树深度是O(logn)的，因此总复杂度为O(nlogn+qlog^2n*T) T表示平均度数，由于陈老师非常良心的保证，T不会超过20

Code：

#include<bits/stdc++.h>
#define debug(x) cerr<<#x<<"="<<x<<endl
typedef long long ll;
using namespace std;
const int maxn = 100009;
const ll inf = 1e15;
 
int first[maxn];
struct edg
{
    int next;
    int to;
    int val;
}e[maxn<<1];
int e_sum;
int n,q,rt,sum,cnt,uuz;
vector<pair<int,int> > E[maxn];
pair<ll,ll> Mast[maxn],root[maxn]; // sum , sum*dis
struct Info{int anc,idx,dis;};
vector<Info> List[maxn];
int siz[maxn],W[maxn];
ll val[maxn];
bool vis[maxn];
  
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline void add_edg(int x,int y,int z)
{
    e_sum++;
    e[e_sum].next=first[x];
    first[x]=e_sum;
    e[e_sum].to=y;
    e[e_sum].val=z;
}
  
void find(int x,int f)
{
    W[x]=0;siz[x]=1;
    for(int i=first[x];i;i=e[i].next)
    {
        int w=e[i].to;
        if(w==f||vis[w]) continue;
        find(w,x);
        siz[x]+=siz[w];
        W[x]=max(W[x],siz[w]);
    }W[x]=max(W[x],sum-siz[x]);
    if(W[x]<W[rt]) rt=x;
}
void dfs(int x,int f,int dis)
{
    List[x].push_back((Info){rt,cnt,dis});
    for(int i=first[x];i;i=e[i].next)
    {
        int w=e[i].to;
        if(w==f||vis[w]) continue;
        dfs(w,x,dis+e[i].val);
    }
}
void solve(int x)
{
    vis[x]=1;
    for(int i=first[x];i;i=e[i].next)
    {
        int w=e[i].to;
        if(vis[w]) continue;
        cnt++;dfs(w,x,e[i].val);
    }
    for(int i=first[x];i;i=e[i].next)
    {
        int w=e[i].to;
        if(vis[w]) continue;
        rt=0;sum=siz[w];
        find(w,0);
        E[x].push_back(make_pair(rt,w));
        solve(rt);
    }
}
  
void update(int x,int delta)
{
    int sz=List[x].size();
    for(int i=0;i<sz;i++)
    {
        Mast[List[x][i].anc].first+=delta;
        Mast[List[x][i].anc].second+=1ll*delta*List[x][i].dis;
        root[List[x][i].idx].first+=delta;
        root[List[x][i].idx].second+=1ll*delta*List[x][i].dis;
    }val[x]+=delta;
}
ll calc(int x)
{
    int sz=List[x].size();
    ll res=Mast[x].second;
    for(int i=0;i<sz;i++)
    {
        res+=1ll*val[List[x][i].anc]*List[x][i].dis;
        res+=1ll*(Mast[List[x][i].anc].first-root[List[x][i].idx].first)*List[x][i].dis;
        res+=1ll*(Mast[List[x][i].anc].second-root[List[x][i].idx].second);
    }
    return res;
}
ll query()
{
    int x=uuz;
    while(true)
    {
        ll res=calc(x),now=inf;int sz=E[x].size();pair<int,int> nxt;
        for(int i=0;i<sz;i++)
        {
            int w=E[x][i].second;
            ll tmp=calc(w);
            if(tmp<now){now=tmp;nxt=E[x][i];}
        }
        if(now>=res) return res;
        res=now;x=nxt.first;
    }
}

int main()
{
    n=read();q=read();
    for(int i=1;i<n;i++)
    {
        int x=read(),y=read(),z=read();
        add_edg(x,y,z);add_edg(y,x,z);
    }
    rt=0;sum=n;W[0]=n+1;
    find(1,0);uuz=rt;
    solve(rt);
    while(q--)
    {
        int x=read(),y=read();
        update(x,y);
        printf("%lld\n",query());
    }
    return 0;
}