這道題有 3 個操作：

1. 換根

2. 求 LCA

3. 子樹修改/子樹求和.

對於第一個操作，直接換根就行.

對於第二個操作，分這幾種情況討論：$x,y$ 都在以 1 為根，$rt$ 的子樹中，$x,y$ 其中 1 個在子樹中，$x,y$ 都不在子樹中.

對於都在子樹中的情況，答案即為 $lca(x,y)$；對於第 2 種情況，答案為 RT；對於第 3 種情況，可以求 a1=lca(x,rt),a2=lca(y,rt),a3=lca(x,y)，然後我們發現 lca 為 3 者深度最大值對應的那個，然後前兩種情況也可以被歸納成 a1,a2,a3 中深度最大的那個.

對於第三個操作，還是分 3 種情況討論：x=RT，RT 在 x 的子樹中，RT 不在 x 的子樹中.

程式碼還是非常好寫的，一遍過.

code:

#include <cstdio> 
#include <cstring> 
#include <vector> 
#include <algorithm>   
#define N 100009   
#define ll long long 
#define lson now<<1  
#define rson now<<1|1   
#define setIO(s) freopen(s".in","r",stdin) 
using namespace std;          
int tim,edges,n,RT;        
ll sum[N<<2],lazy[N<<2];  
int a[N],dep[N],bu[N],len[N<<2];  
int hd[N],to[N<<1],nex[N<<1],fa[20][N],st[N],ed[N];  
void add(int u,int v) {  
    nex[++edges]=hd[u],hd[u]=edges,to[edges]=v;  
}     
void dfs(int x,int ff) { 
    fa[0][x]=ff,dep[x]=dep[ff]+1;  
    st[x]=++tim,bu[tim]=x;     
    for(int i=1;i<20;++i) fa[i][x]=fa[i-1][fa[i-1][x]];   
    for(int i=hd[x];i;i=nex[i]) {  
        int y=to[i]; 
        if(y==ff) continue;   
        dfs(y,x);      
    }
    ed[x]=tim;  
}           
void pushup(int now) {   
    sum[now]=sum[lson]+sum[rson]; 
}    
void mark(int now,ll v) {  
    sum[now]+=(ll)len[now]*v;   
    lazy[now]+=v; 
}  
void pushdown(int now) {  
    if(lazy[now]) { 
        mark(lson,lazy[now]); 
        mark(rson,lazy[now]); 
        lazy[now]=0; 
    }
}
void build(int l,int r,int now) { 
    len[now]=r-l+1;  
    if(l==r) { 
        sum[now]=a[bu[l]];  
        return; 
    }  
    int mid=(l+r)>>1;  
    build(l,mid,lson),build(mid+1,r,rson); 
    pushup(now);   
}    
void update(int l,int r,int now,int L,int R,ll v) {  
    if(l>=L&&r<=R) {  
        mark(now,v); 
        return; 
    }  
    pushdown(now); 
    int mid=(l+r)>>1;  
    if(L<=mid)  update(l,mid,lson,L,R,v); 
    if(R>mid)   update(mid+1,r,rson,L,R,v);  
    pushup(now); 
}  
ll query(int l,int r,int now,int L,int R) { 
    if(l>=L&&r<=R) return sum[now];  
    pushdown(now);    
    int mid=(l+r)>>1;  
    ll re=0; 
    if(L<=mid)  re+=query(l,mid,lson,L,R); 
    if(R>mid)   re+=query(mid+1,r,rson,L,R);  
    return re; 
}    
int get_up(int x,int kth) {  
    for(int i=19;i>=0;--i) { 
        if(dep[x]-dep[fa[i][x]]<=kth) { 
            kth-=(dep[x]-dep[fa[i][x]]);    
            x=fa[i][x];  
        }
    }   
    return x;     
}   
int LCA(int x,int y) {  
    if(dep[x]>dep[y]) swap(x,y);    
    if(dep[x]!=dep[y]) {  
        for(int i=19;i>=0;--i) {  
            if(dep[fa[i][y]]>=dep[x]) y=fa[i][y];   
        }
    }
    if(x==y) return x;  
    for(int i=19;i>=0;--i) { 
        if(fa[i][x]!=fa[i][y]) { 
            x=fa[i][x]; 
            y=fa[i][y];  
        }
    }   
    return fa[0][x];    
}  
int get_lca(int x,int y) {    
    int a1=LCA(x,y),a2=LCA(x,RT),a3=LCA(y,RT);   
    if(dep[a1]<dep[a2]) a1=a2;   
    if(dep[a1]<dep[a3]) a1=a3;  
    return a1;   
}
void modify_subtree(int x,ll v) {    
    if(x==RT) {    
        update(1,n,1,1,n,v);     
    }   
    else if(st[RT]>=st[x]&&st[RT]<=ed[x]) {  
        update(1,n,1,1,n,v);   
        int z=get_up(RT,dep[RT]-dep[x]-1);      
        update(1,n,1,st[z],ed[z],-v);  
    }  
    else {    
        update(1,n,1,st[x],ed[x],v);  
    }
}
ll query_subtree(int x) {      
    if(x==RT) {    
        return sum[1];  
    }   
    else if(st[RT]>=st[x]&&st[RT]<=ed[x]) {   
        int z=get_up(RT,dep[RT]-dep[x]-1);      
        return sum[1]-query(1,n,1,st[z],ed[z]);  
    }  
    else {    
        return query(1,n,1,st[x],ed[x]);  
    }
}
int main() {  
    // setIO("input");     
    int x,y,z,m,op;       
    scanf("%d%d",&n,&m);    
    for(int i=1;i<=n;++i)  scanf("%d",&a[i]); 
    for(int i=1;i<n;++i) {  
        scanf("%d%d",&x,&y);    
        add(x,y),add(y,x);   
    }    
    RT=1;  
    dfs(1,0);   
    build(1,n,1);          
    for(int i=1;i<=m;++i) {  
        scanf("%d",&op);   
        if(op==1) scanf("%d",&RT);   
        if(op==2) {         
            scanf("%d%d%d",&x,&y,&z);  
            int lca=get_lca(x,y);   
            modify_subtree(lca,z);  
        }
        if(op==3) {    
            scanf("%d",&x);  
            printf("%lld\n",query_subtree(x));  
        }
    }
    return 0;
}