没有换根操作
考虑如果没有换根操作，我们该怎么做。
我们可以求出原树的(dfs)序列，然后开线段树维护。
对于修改操作，我们可以倍增求(LCA)，然后在线段树上修改子树内的值。
对于询问操作，我们直接查询子树内的值。
但有了换根操作，(LCA)就可能不再是原来的(LCA)，子树也就可能不再是原来的子树了。
换根操作后的(LCA)
通过一波画图+找规律，我们可以发现，在根为(rt)时，换根操作后的(LCA(x,y))大致有如下几种情况：（以下讨论中(x,y)互换同理）
- 若(rt)在(x)的子树内，且(y)也在(x)的子树内，(LCA)就是(LCA(y,rt))。
- 若(rt)在(x)的子树内，但(y)不在(x)的子树内，(LCA)就是(x)。
- 若(x)在(rt)的子树内，且(y)不在(rt)的子树内，(LCA)就是(rt)。
- 除去以上情况，设(t=LCA(x,y))，若(rt)不在(t)的子树内，(LCA)就是(t)。
- 否则，设(t1=LCA(x,rt),t2=LCA(y,rt))，(LCA)就是(t1)与(t2)中深度较大的那个。
是不是很复杂？
换根操作后的子树
这比(LCA)良心多了，只用分两种情况讨论。
若(rt)不在(x)子树内，处理的就是(x)的子树。
否则，我们找到(rt)在(x)哪个儿子的子树内，然后处理树上除该子树外的其他部分。其实就是(dfs)序列中的一段前缀和一段后缀。
不过除了这两种情况外，还有一种特殊情况需要注意，即(x=rt)时，处理整棵树。
代码
#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 300000
#define LN 20
#define LL long long
#define add(x,y) (e[++ee].nxt=lnk[x],e[lnk[x]=ee].to=y)
#define swap(x,y) (x^=y^=x^=y)
using namespace std;
int n,Qt,rt=1,ee,lnk[N+5];LL a[N+5];struct edge {int to,nxt;}e[N<<1];
class FastIO
{
private:
#define FS 100000
#define tc() (A==B&&(B=(A=FI)+fread(FI,1,FS,stdin),A==B)?EOF:*A++)
#define pc(c) (C==E&&(clear(),0),*C++=c)
#define tn (x<<3)+(x<<1)
#define D isdigit(c=tc())
int f,T;char c,*A,*B,*C,*E,FI[FS],FO[FS],S[FS];
public:
I FastIO() {A=B=FI,C=FO,E=FO+FS;}
Tp I void read(Ty& x) {x=0,f=1;W(!D) f=c^'-'?1:-1;W(x=tn+(c&15),D);x*=f;}
Ts I void read(Ty& x,Ar&... y) {read(x),read(y...);}
Tp I void write(Ty x) {x<0&&(pc('-'),x=-x);W(S[++T]=x%10+48,x/=10);W(T) pc(S[T--]);}
Tp I void writeln(Con Ty& x) {write(x),pc('
');}
I void clear() {fwrite(FO,1,C-FO,stdout),C=FO;}
}F;
template<int SZ> class SegmentTree//线段树
{
private:
#define L l,mid,rt<<1
#define R mid+1,r,rt<<1|1
#define PU(x) (V[x]=V[x<<1]+V[x<<1|1])
#define PD(x,ls,rs) F[x]&&(U(x<<1,F[x],ls),U(x<<1|1,F[x],rs),F[x]=0)
#define U(x,v,s) (V[x]+=1LL*(s)*v,F[x]+=v)
int n;LL V[N<<2],F[N<<2];
I void Build(LL *a,int *fac,CI l,CI r,CI rt)//建树
{
if(l==r) return (void)(V[rt]=a[fac[l]]);RI mid=l+r>>1;
Build(a,fac,L),Build(a,fac,R),PU(rt);
}
I void Upt(CI tl,CI tr,CI tv,CI l,CI r,CI rt)//区间修改
{
if(tl<=l&&r<=tr) return (void)U(rt,tv,r-l+1);RI mid=l+r>>1;PD(rt,mid-l+1,r-mid);
tl<=mid&&(Upt(tl,tr,tv,L),0),tr>mid&&(Upt(tl,tr,tv,R),0),PU(rt);
}
I LL Qry(CI tl,CI tr,CI l,CI r,CI rt)//区间询问
{
if(tl<=l&&r<=tr) return V[rt];RI mid=l+r>>1;PD(rt,mid-l+1,r-mid);
return (tl<=mid?Qry(tl,tr,L):0)+(tr>mid?Qry(tl,tr,R):0);
}
public:
I void Init(CI _n,LL *a,int *fac) {Build(a,fac,1,n=_n,1);}
I void Upt(CI l,CI r,CI v) {l<=r&&(Upt(l,r,v,1,n,1),0);}
I LL Qry(CI l,CI r) {return l<=r?Qry(l,r,1,n,1):0;}
};
class DfnSolver//dfs序列上开线段树
{
private:
#define Include(x,y) (dfn[x]<=dfn[y]&&dfn[y]<=dfn[x]+Sz[x]-1)
int d,dep[N+5],fa[N+5][LN+5],Sz[N+5],dfn[N+5],fac[N+5];SegmentTree<N> S;
I void dfs(CI x=1)//dfs求出dfs序
{
RI i;for(fac[dfn[x]=++d]=x,i=1;i<=LN;++i) fa[x][i]=fa[fa[x][i-1]][i-1];//预处理倍增祖先
for(Sz[x]=1,i=lnk[x];i;i=e[i].nxt) e[i].to^fa[x][0]&&
(dep[e[i].to]=dep[fa[e[i].to][0]=x]+1,dfs(e[i].to),Sz[x]+=Sz[e[i].to]);
}
I int LCA(RI x,RI y)//倍增求LCA
{
RI i;for(dep[x]<dep[y]&&swap(x,y),i=0;dep[x]^dep[y];++i) (dep[x]^dep[y])>>i&1&&(x=fa[x][i]);
if(x==y) return x;for(i=LN;~i;--i) fa[x][i]^fa[y][i]&&(x=fa[x][i],y=fa[y][i]);return fa[x][0];
}
I int GetLCA(CI x,CI y)//求出换根操作后的LCA，分类讨论
{
if(Include(x,rt)) return Include(x,y)?LCA(y,rt):x;
if(Include(y,rt)) return Include(y,x)?LCA(x,rt):y;
if(Include(rt,x)^Include(rt,y)) return rt;
RI t=LCA(x,y);if(!Include(t,rt)) return t;
RI t1=LCA(x,rt),t2=LCA(y,rt);return dep[t1]>dep[t2]?t1:t2;
}
I int Jump(RI x,RI d) {for(RI i=0;dep[x]^d;++i) (dep[x]^d)>>i&1&&(x=fa[x][i]);return x;}//树上倍增，跳到对应深度
I void Upt(CI x,CI v)//修改子树
{
if(x==rt) return S.Upt(1,n,v);if(!Include(x,rt)) return S.Upt(dfn[x],dfn[x]+Sz[x]-1,v);
RI k=Jump(rt,dep[x]+1);S.Upt(1,dfn[k]-1,v),S.Upt(dfn[k]+Sz[k],n,v);
}
I LL Qry(CI x)//询问子树
{
if(x==rt) return S.Qry(1,n);if(!Include(x,rt)) return S.Qry(dfn[x],dfn[x]+Sz[x]-1);
RI k=Jump(rt,dep[x]+1);return S.Qry(1,dfn[k]-1)+S.Qry(dfn[k]+Sz[k],n);
}
public:
I void Solve()
{
dfs(),S.Init(n,a,fac);RI op,x,y,v;
W(Qt--) switch(F.read(op,x),op)//读入操作并处理
{
case 1:rt=x;break;
case 2:F.read(y,v),Upt(GetLCA(x,y),v);break;
case 3:F.writeln(Qry(x));break;
}
}
}T;
int main()
{
freopen("tree.in","r",stdin),freopen("tree.out","w",stdout);
RI i,x,y;for(F.read(n,Qt),i=1;i<=n;++i) F.read(a[i]);
for(i=1;i^n;++i) F.read(x,y),add(x,y),add(y,x);return T.Solve(),F.clear(),0;
}