偶然发现这题我写了然后交上去就似了

下了数据发现输出是一样的

#include<bits/stdc++.h>
#define MAXM 0X66CCFF
#define int long long
#define INF 0X66CCFF0712
namespace IO{
    inline void close(){std::ios::sync_with_stdio(false);std::cin.tie(0);std::cout.tie(0);}
    inline void Fire(){freopen(".in","r",stdin);freopen(".out","w",stdout);}
    inline int read(){int s = 0,w = 1;char ch = getchar();while(ch<'0'||ch>'9'){ if(ch == '-') w = -1;ch = getchar();}while(ch>='0'&&ch<='9'){ s = s*10+ch-'0';ch = getchar();}return s*w;}
    inline void write(int x){char F[200];int tmp=x>0?x:-x,cnt=0;;if(x<0)putchar('-') ;while(tmp>0){F[cnt++]=tmp%10+'0';tmp/=10;}while(cnt>0)putchar(F[--cnt]);}
}
using namespace IO;
int head[MAXM],NEXT[MAXM],TO[MAXM],cnt,tot,a[MAXM],R,root=1,N,M;
struct node{
    int fa,dep,siz,son,top;
    int dfn,rnk;
}T[MAXM];
namespace Grape{
    inline void add(int u,int v){
        NEXT[++tot]=head[u];
        TO[tot]=v;
        head[u]=tot;
    }
}
namespace ST{
    #define mid (l+r)/2
    #define lC q<<1
    #define rC q<<1|1
    struct St{
        long long l,r,siz;
        long long lazy,dat,mindat;
    }t[0x66ccff];
    void build(int q,int l,int r){
        t[q].l=l;
        t[q].r=r;
        t[q].siz=r-l+1;
        t[lC].mindat=INF;
        t[rC].mindat=INF;
        if(l==r){
            t[q].mindat=a[T[l].rnk];
            return;
        }
        build(lC,l,mid);
        build(rC,mid+1,r);
        t[q].mindat=std::min(t[lC].mindat,t[rC].mindat);
    }
    void lazy(int q){
        t[lC].lazy=t[q].lazy;
        t[lC].mindat=t[q].lazy;
        t[rC].lazy=t[q].lazy;
        t[rC].mindat=t[q].lazy;
        t[q].lazy=0;
    }
    void change(int q,int l,int r,int v){
        if(t[q].l>r||t[q].r<l) return;
        if(t[q].l>=l && t[q].r<=r){
            t[q].mindat=t[q].lazy=v;
            return;
        }
        if(t[q].lazy!=0)
            lazy(q);
        change(lC,l,r,v);
        change(rC,l,r,v);
        t[q].mindat=std::min(t[lC].mindat,t[rC].mindat);
    }
    inline int Askmin(int q,int l,int r){
        if(t[q].l>r || t[q].r<l) 
            return INF;
        if(t[q].l>=l && t[q].r<=r) 
            return t[q].mindat;
        if(t[q].lazy!=0)
            lazy(q);
        return std::min(Askmin(lC,l,r),Askmin(rC,l,r)); 
    }
}
namespace killTree{
    inline void Dfs1(int q){
        T[q].son=-1;
        T[q].siz=1;
        for(int j=head[q];j;j=NEXT[j]){
            if(T[TO[j]].dep) continue;
            T[TO[j]].dep=T[q].dep+1;
            T[TO[j]].fa=q;
            Dfs1(TO[j]);
            T[q].siz+=T[TO[j]].siz;
            if((T[q].son==-1) || (T[TO[j]].siz>T[T[q].son].siz)) T[q].son=TO[j];
        }
    }
    inline void Dfs2(int q,int v){
        T[q].top=v;
        T[q].dfn=++cnt;
        T[cnt].rnk=q;
        if(T[q].son==-1)
            return;
        Dfs2(T[q].son,v);
        for(int j=head[q];j;j=NEXT[j]){
            if((TO[j]!=T[q].fa)&&(TO[j]!=T[q].son))
                Dfs2(TO[j],TO[j]);
        }
    }
    inline int lca(int u,int v){
        while(T[u].top!=T[v].top) {
            if(T[T[u].top].dep > T[T[v].top].dep)  u=T[T[u].top].fa;
            else  v=T[T[v].top].fa;
        }
        return T[u].dep>T[v].dep?v:u;
    }
    inline int Get(int x,int y){ 
        while(T[x].top!=T[y].top){
            if(T[T[x].top].dep < T[T[y].top].dep) std::swap(x,y);
            if(T[T[x].top].fa == y) return T[x].top;
            x=T[T[x].top].fa;
        }
        if(T[x].dep>T[y].dep) std::swap(x,y);
        return T[x].son;
    }
    inline void TreeAdd(int x,int y,int val){
        while(T[x].top!=T[y].top){
            if(T[T[x].top].dep<T[T[y].top].dep) 
                std::swap(x,y);
            ST::change(1,T[T[x].top].dfn,T[x].dfn,val);
            x=T[T[x].top].fa;
        }
        if(T[x].dep>T[y].dep) 
            std::swap(x,y);
        ST::change(1,T[x].dfn,T[y].dfn,val);
    }
    inline int AskTree(int x){
        if(x==root){
                #ifdef debug
                return 0X66CCFF;
                #endif
            return ST::t[1].mindat;
        }
        else if(T[x].dfn>T[root].dfn || T[x].dfn+T[x].siz-1<T[root].dfn){
                #ifdef debug
                return 0X66CCFF;//marked
                #endif
            return ST::Askmin(1,T[x].dfn,T[x].dfn+T[x].siz-1);
        } 
        else{
            int ch=Get(x,root);    
            if(T[ch].dfn+T[ch].siz-1==N)
                return ST::Askmin(1,1,T[ch].dfn-1);
            else return std::min(ST::Askmin(1,1,T[ch].dfn-1),ST::Askmin(1,T[ch].dfn+T[ch].siz,N));
        }
    }
    inline void EXchange(int x){
        root=x; 
    }
}
signed main(){
    freopen("1.in","r",stdin);
    freopen("1.out","w",stdout);
    N=read(),M=read();
    for(int i=2;i<=N;i++){
        int u=read(),v=read();
        Grape::add(u,v);
        Grape::add(v,u);
    }
    for(int i=1;i<=N;i++) a[i]=read();
    int rt=read();
    T[rt].dep=1;
    killTree::Dfs1(rt);
    killTree::Dfs2(rt,rt);
    ST::build(1,1,N);
    for(int i=1;i<=M;i++){
        char q=getchar();
        if(q=='2'){
            int x=read(),y=read();
            killTree::TreeAdd(x,y,read());
        }
        else if(q=='1'){
            killTree::EXchange(read());
        }
        else if(q=='3'){
            std::cout<<killTree::AskTree(read())<<std::endl;
        }
    }
}