题意:
现在有一棵大小为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;
}