2020牛客暑期多校训练营（第七场）c题 A National Pandemic

题意：
现在有一棵大小为n的树，有m个操作，每次有三种操作：
定义dis(x,y)为从x到y的边数
1 x w 位置x上的权值+w，同时所有位置的权值加上w-dis(x,y)
2 x 将x位置的权值对0取个最小值
3 x 问x位置的权值是多少

考虑独立统计每个点受到各个1操作的影响
2操作是卖萌的，每次只要查询这个点当时的值判断是否大于0，然后维护一个delta数组即可，但是暗藏杀机，请自行阅读代码
一个对x的1操作将对y点产生w-dist(x,y)的影响，可以化简为
w-deep(x)-deep(y)+2deep(lca(x,y))；
那对于很多次1操作对y节点产生的累加影响，我们发现w-deep(x)部分可以用一个sum变量来统计，每一次1操作的时候直接加即可
对于-deep(y)操作的累加影响，每一次1操作产生一个，记录一个cnt表示1操作了多少次，统计权值的时候直接-cntdeep（y）就完事了
对于+2deep(lca(x,y))，我们先考虑deep(lca(x,y))，那个2在统计的时候搞即可。对于每次1操作，我们把x点到1（根）的路径上每条边的权值都+1，树剖了用线段树（或树状数组）维护，累加这个操作，这样当我们查询y的时候，可以理解为y点到lca的路都没加，但是lca往上的部分每条边被+1，刚好就是深度deep。画个图就很容易证明无论x在y的下方，上方还是不同子树，这样的操作都是正确的。
这里需要好好体会。

总结：1.不要被各种可怕的操作吓到，有些操作就是纸老虎，辨析真伪还需多做多看多积累
2.分治思想不仅体现在把区间一分为二，还体现在集合操作（每个点都要操作）对个体产生的影响（其实这一点我考场上有往这个方向想），列出了公式之后对于公式的每一个部分还可以分开了应对。
3.树上的很多问题化到最后都是路径问题，尤其是最短距离，和lca有直接关系。树剖是一个自带求lca功能的东西，所以以后看到类似的问题提供一种新思路，就是不一定非要把lca求出来，而是利用树剖的这种性质来构造。

拓展：若本题的树改为有权树还可以做吗？我太菜实在没想到。
公式w-deep(x)-deep(y)一如既往地很容易维护，
但是维护deep(lca(x,y))时不能对x到根的所有点全部+1，因为每条边长度不同了，需要一个个加。

花絮：线段树一定要开大不然会死的！！因为这个T了一小时后来发现是RE！开至少4倍！

//#include"bits/stdc++.h"
//#include<unordered_map>
//#include<unordered_set>
#include <cstring>
#include <fstream>
#include <iostream>
#include <string>
#include <string.h>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstdio>
 
#define ll long long
#define sc(x) scanf("%d",&x)
#define pr(x) printf("%d",x)
#define scl(x) scanf("%lld",&x)
#define prl(x) printf("%lld",x)
#define prn(x) printf("%d\n",x)
 
#define fin for(int i=1;i<=n;i++)
#define fim for(int j=1;j<=m;j++)
//freopen("t.txt","r",stdin);
//freopen("a.out","w",stdout);
#define seto struct o{int x;int y;};bool comp(o a,o b){return a.x>b.x;}
#define prio priority_queue<int>q;
#define prio1 priority_queue<int,vector<int>,greater<int> >q;
#define pb push_back
//map<int,int>mp;map<int,int>::iterator it;
//for(it=mp.begin();it!=mp.end();it++)
#define VEC vector<int>
#define sf sizeof
#define sz size()
#define emp empty()
#define mem memset
using namespace std;
vector<ll>e[50005];
struct node
{
    ll l,r,ls,rs,sum,lazy;
}a[300005];//区间左右，左右儿子，和权值，懒标记
ll n,m,r,rt,mod=1e16,//不用模则将mod置为无穷大
head[50005],cnt,f[50005],
d[50005],son[50005],size[50005],
top[50005],id[50005],rk[50005];
ll del[50005];
void dfs1(ll x,ll fa)
{
    d[x]=d[fa]+1;ll v;//记录深度
    for(ll i=0;i<e[x].size();i++)
    {
        v=e[x][i];
        if(v!=f[x])
        {
            f[v]=x;
            dfs1(v,x);
            size[x]+=size[v];
            if(size[v]>size[son[x]])//标记重儿子
            son[x]=v;
        }
    }
    size[x]++; //记录子树点的个数
}
/*
第二遍dfs，然后连接重链，同时标记每一个节点的dfs序，
并且为了用数据结构来维护重链，
我们在dfs时保证一条重链上各个节点dfs序连续（即处理出数组top,id,rk）
*/
void dfs2(ll x,ll tp)
{
    top[x]=tp;//标记重链顶端
    id[x]=++cnt;
    rk[cnt]=x;//id和rank互逆，存储x节点的新dfs序号和这个序号对应的节点
    if(son[x])
    dfs2(son[x],tp);//有重儿子就最先做，该重链的顶部还是tp
    //没有重儿子说明已经到底部了，这时候再一个个遍历轻儿子
    ll v;
    for(ll i=0;i<e[x].size();i++)
    {
        v=e[x][i];
        if(v!=f[x]&&v!=son[x])//不能再做一次重儿子了！
            dfs2(v,v);
    }
}
//线段树维护重链 ，区间加法版
void build(ll l,ll r,ll x)
{
    if(l==r)
    {
        a[x].sum=0,a[x].l=a[x].r=l;
        return;
    }
    ll mid=(l+r)>>1;
    a[x].ls=cnt++,a[x].rs=cnt++;
    build(l,mid,a[x].ls),build(mid+1,r,a[x].rs);
    a[x].l=a[a[x].ls].l;
    a[x].r=a[a[x].rs].r;
    a[x].sum=(a[a[x].ls].sum+a[a[x].rs].sum);
}
inline ll len(ll x)
{
    return a[x].r-a[x].l+1;
}
inline void pushdown(ll x)
{
    if(a[x].lazy)
    {
        ll ls=a[x].ls,rs=a[x].rs,lz=a[x].lazy;
        (a[ls].lazy+=lz),(a[rs].lazy+=lz);
        (a[ls].sum+=lz*len(ls)),(a[rs].sum+=lz*len(rs));
        //该点被访问，将懒标记下传，
        a[x].lazy=0;
    }
}
void update(ll l,ll r,ll c,ll x)//区间l-r整体全+c
{
    if(a[x].l>=l&&a[x].r<=r)
    {//整个区间都覆盖就直接懒标记
        (a[x].lazy+=c),(a[x].sum+=len(x)*c);
        return;
    }
    pushdown(x);
    ll mid=(a[x].l+a[x].r)>>1;
    if(mid>=l)
        update(l,r,c,a[x].ls);
    if(mid<r)
        update(l,r,c,a[x].rs);
    a[x].sum=(a[a[x].ls].sum+a[a[x].rs].sum);
}
ll query(ll l,ll r,ll x)
{
    if(a[x].l>=l&&a[x].r<=r)
        return a[x].sum;
    pushdown(x);
    ll mid=a[x].l+a[x].r>>1,tot=0;
    if(mid>=l)
        tot+=query(l,r,a[x].ls);
    if(mid<r)
        tot+=query(l,r,a[x].rs);
    return tot;
}
inline ll sum(ll x,ll y)//求x到y路径上所有节点之和 ，解释见下一个函数
{
    ll ret=0;
    while(top[x]!=top[y])
    {
        if(d[top[x]]<d[top[y]])
            swap(x,y);
        ret+=query(id[top[x]],id[x],rt);ret;
        x=f[top[x]];
    }
    if(id[x]>id[y])
        swap(x,y);
    return (ret+query(id[x],id[y],rt));
}
inline void updates(ll x,ll y,ll c)
{//将树从x到y结点最短路径上所有节点的值都加上z
    while(top[x]!=top[y])//其实已经在求LCA
    {
        if(d[top[x]]<d[top[y]])
            swap(x,y);//确保x比y深，以降低树剖复杂度
        update(id[top[x]],id[x],c,rt);//把这个点到重链顶端全部加，因为这条重链必然在路径上
        x=f[top[x]];//跳到上一条重链
    }//直到跳到同一条重链
    if(id[x]>id[y])
        swap(x,y);//确保x比y编号小，线段树加法不出问题
    update(id[x],id[y],c,rt);//线段树加权
}
void init(int n)
{
    for(int i=0;i<=n;i++)
    e[i].clear();

    mem(a,0,sf a);
   
    for(int i=0;i<=n;i++)
    {
        d[i]=0;
        size[i]=0;
        del[i]=0;
        son[i]=0;
        head[i]=0;
        top[i]=0;
        f[i]=0;
        id[i]=0;
        rk[i]=0;
    }
}
ll S,n1;
ll calc(int x)
{
    return S-n1*(d[x])+2*sum(1,x);
}
int main()
{
    r=1;
    int T;
    sc(T);
    while(T--)
    {
        sc(n);sc(m);
        init(n);
         
         for(int i=1;i<n;i++)
        {
            ll x,y;
            scanf("%lld%lld",&x,&y);
            e[x].push_back(y);
            e[y].push_back(x);
        }//树剖初始化
        cnt=0,dfs1(r,0),dfs2(r,r);
        //线段树初始化
        cnt=0,rt=cnt++,build(1,n,rt);
        //从这里开始就已经按照dfs序列构造线段树，所以rt编号为1
         
         S=0,n1=0;
        ll opt,xx,ww;
        fim
        {
            scl(opt);
            if(opt==1)
            {
                scl(xx);scl(ww);
                S+=ww-d[xx];
                n1++;
                updates(1,xx,1);
            }
            if(opt==2)
            {
                scl(xx);
                ll ans=calc(xx)-del[xx];
                if(ans>0)
                del[xx]+=ans;
            }
            if(opt==3)
            {
                scl(xx);
                ll ans=calc(xx);
                printf("%lld\n",ans-del[xx]);
            }
             
        }
    }
 
     
    return 0;
}