2020牛客多校第七场--C. A National Pandemic（树链剖分维护换根

题意：https://ac.nowcoder.com/acm/contest/5672/B

树上：3种操作，1。某点+x，2。某点清零，3。查询某点的值（计算方式是Sigma（val_to - dis(u,to))

思路：

考虑换根（我们肯定不能暴力换根），每次向下移动其实就是++--一些东西，在链上按点的贡献维护这种东西（树链剖分），查询也类型

struct EDGE
{
    int to,next;
}edge[N<<1];
int etot;
int head[N];
void Init(int n)
{
    etot=0;
    for(int i=0;i<=n;++i)
        head[i]=0;
}
void add(int from,int to)
{
    ++etot;
    edge[etot].to=to;
    edge[etot].next=head[from];
    head[from]=etot;
}//for(int i=head[u];i;i=edge[i].next)



int sum[N<<2];
int lazy[N<<2];

void up(int rt)
{
    sum[rt]=sum[ls]+sum[rs];
}

void dn(int rt,int l,int r)
{
    if(lazy[rt]!=0)
    {
        lazy[ls]+=lazy[rt];
        lazy[rs]+=lazy[rt];
        sum[ls]+=lazy[rt]*l;
        sum[rs]+=lazy[rt]*r;
        lazy[rt]=0;
    }
}

void Build(int l,int r,int rt)
{
    sum[rt]=lazy[rt]=0;
    if(l==r)
    {
        return;
    }
    int mid=(l+r)>>1;

    Build(l,mid,rt<<1);
    Build(mid+1,r,rt<<1|1);
    up(rt);
}
void update_qu(int L,int R,int V,int l,int r,int rt)
{
    if(L>R)return;
    if(L<=l&&r<=R)
    {
        sum[rt]+=V*(r-l+1);
        lazy[rt]+=V;
        return;
    }

    int mid=(l+r)>>1;
    dn(rt,mid-l+1,r-mid);
    if(L<=mid)
        update_qu(L,R,V,l,mid,rt<<1);
    if(R>mid)
        update_qu(L,R,V,mid+1,r,rt<<1|1);
    up(rt);
}
int Q(int L,int R,int l,int r,int rt)
{
    if(L>R)return 0;
    if(L<=l&&r<=R)
    {
        return sum[rt];
    }

    int ans=0;
    int mid=(l+r)>>1;
    dn(rt,mid-l+1,r-mid);
    if(L<=mid)
        ans+=Q(L,R,l,mid,rt<<1);
    if(R>mid)
        ans+=Q(L,R,mid+1,r,rt<<1|1);
    up(rt);
    return ans;
}


class TREECUT//树链剖分
{
public:
    int DFN,n;
    int f[N],d[N],sz[N],hson[N],top[N],dfn[N],real[N];
    void Init(int _n)
    {
        DFN=0;
        n=_n;
        for(int i=0;i<=n;++i)
            hson[i]=top[i]=real[i]=0;
    }
    void dfs1(int u,int fa,int deep)
    {
        sz[u]=1;
        d[u]=deep;
        f[u]=fa;
        for(int i=head[u];i;i=edge[i].next)
        {
            int to=edge[i].to;
            if(to==fa)continue;
            dfs1(to,u,deep+1);
            sz[u]+=sz[to];
            if(sz[to]>sz[hson[u]])hson[u]=to;
        }
    }
    void dfs2(int u,int t)
    {
        top[u]=t;
        dfn[u]=++DFN;
        real[DFN]=u;
        if(!hson[u])return;
        dfs2(hson[u],t);
        for(int i=head[u];i;i=edge[i].next)
        {
            int to=edge[i].to;
            if(to==f[u]||to==hson[u])continue;
            dfs2(to,to);
        }
    }
    void go_add(int x,int y)
    {
        int fx=top[x],fy=top[y];
        while(fx!=fy)//两点不在同一条重链
        {
            if(d[fx]>=d[fy])
            {
                update_qu(dfn[fx],dfn[x],2,1,n,1);
//                res.push_back({dfn[fx],dfn[x]});
                x=f[fx],fx=top[x];
            }
            else
            {
                update_qu(dfn[fy],dfn[y],2,1,n,1);
//                res.push_back({dfn[fy],dfn[y]});
                y=f[fy],fy=top[y];
            }
        }
        if(dfn[x]<=dfn[y])
            update_qu(dfn[x],dfn[y],2,1,n,1);//,res.push_back({dfn[x],dfn[y]});//,LCA=x;
        else
            update_qu(dfn[y],dfn[x],2,1,n,1);//,res.push_back({dfn[y],dfn[x]});//,LCA=y;
    }
    int get_sum(int x,int y)
    {
        int ans=0,fx=top[x],fy=top[y];
        while(fx!=fy)//两点不在同一条重链
        {
            if(d[fx]>=d[fy])
            {
                ans+=Q(dfn[fx],dfn[x],1,n,1);
                x=f[fx],fx=top[x];
            }
            else
            {
                ans+=Q(dfn[fy],dfn[y],1,n,1);
                y=f[fy],fy=top[y];
            }
        }
        if(dfn[x]<=dfn[y])
            ans+=Q(dfn[x],dfn[y],1,n,1);//,LCA=x;
        else
            ans+=Q(dfn[y],dfn[x],1,n,1);//,LCA=y;
        return ans;
    }
}TREE;

int _0[N];

void solve()
{
    int n,m;
    sc("%lld%lld",&n,&m);
    for(int i=0;i<=n;++i)_0[i]=0;
    Init(n);
    TREE.Init(n);
    for(int i=1;i<n;++i)
    {
        int u,v;
        sc("%lld%lld",&u,&v);
        add(u,v);
        add(v,u);
    }
    Build(1,n,1);
    TREE.dfs1(1,0,1);
    TREE.dfs2(1,1);
    int Vrt=0;
    int add_ti=0;
    for(int i=1;i<=m;++i)
    {
        int op,x,y;
        sc("%lld",&op);
        if(op==1)
        {
            sc("%lld%lld",&x,&y);
            add_ti++;
            TREE.go_add(1,x);
            Vrt+=y-(TREE.d[x]-1);
        }
        else if(op==2)
        {
            sc("%lld",&x);
            int val=Vrt-add_ti*(TREE.d[x]-1)+TREE.get_sum(1,x)-add_ti*2;
            int real=val+_0[x];
            if(real>0)_0[x]-=real;
        }
        else
        {
            sc("%lld",&x);
//            int temp=TREE.get_sum(1,x);
//            pr("%lld\n",temp);
            int val=Vrt-add_ti*(TREE.d[x]-1)+TREE.get_sum(1,x)-add_ti*2;
            pr("%lld\n",val+_0[x]);
        }
    }
}

signed main()
{
    int T;
    sc("%lld",&T);
    while(T--)solve();
    return 0;
}