BZOJ 3083 遥远的国度

给定一棵有根树，每个点有一个权值，提供三种操作：
1.将x节点变为根节点
2.将x到y路径上的点的权值全部改为v
3.询问x的子树中点权的最小值

树链剖分

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=100005;
const int maxb=18;
typedef unsigned int uint;

int last[maxn],ecnt;
struct Edge{
    int to,nxt;
}edge[maxn<<1];
inline void ins(int u,int v){
    edge[++ecnt]=(Edge){v,last[u]};
    last[u]=ecnt;
}

int Rt;
int lx[maxn],rx[maxn],dfs_clock;
int link[maxn],dep[maxn];
int sz[maxn];
int n,m;

int nxt[maxn][maxb];

void dfs(int x,int f){
    nxt[x][0]=f;
    for(int i=0;nxt[x][i];i++)
        nxt[x][i+1]=nxt[nxt[x][i]][i];

    dep[x]=dep[f]+1;
    sz[x]=1;
    for(int i=last[x];i;i=edge[i].nxt){
        int to=edge[i].to;
        if(to!=f){
            dfs(to,x);
            sz[x]+=sz[to];
        }
    }
}

inline int getup(int x,int d){
    for(int i=maxb-1;i>=0;i--)
        if(d&(1<<i))
            x=nxt[x][i];
    return x;
}

int dfsID[maxn];
void assign(int x,int p){
    lx[x]=++dfs_clock;
    dfsID[dfs_clock]=x;
    link[x]=p;
    int mx=0;
    for(int i=last[x];i;i=edge[i].nxt){
        int to=edge[i].to;
        if(sz[to]<sz[x]&&sz[to]>sz[mx])mx=to;
    }
    if(mx){
        assign(mx,p);
        for(int i=last[x];i;i=edge[i].nxt){
            int to=edge[i].to;
            if(sz[to]<sz[x]&&to!=mx)assign(to,to);
        }
    }
    rx[x]=dfs_clock;
}

uint key[maxn];

struct Segment{
    struct node{
        uint mn,flag;
    }v[maxn<<2];
    inline void up(int x){
        v[x].mn=min(v[x<<1].mn,v[x<<1|1].mn);
    }
    inline void down(int x){
        if(!v[x].flag)return;
        adjust(x<<1,v[x].flag);
        adjust(x<<1|1,v[x].flag);
        v[x].flag=0;
    }
    inline void adjust(int x,uint val){
        v[x].mn=v[x].flag=val;
    }
    uint query(int l,int r,int x,int L,int R){
        if(l==L&&r==R)return v[x].mn;
        int mid=l+r>>1;
        down(x);
        if(R<=mid)return query(l,mid,x<<1,L,R);
        else if(L>mid)return query(mid+1,r,x<<1|1,L,R);
        return min(query(l,mid,x<<1,L,mid),query(mid+1,r,x<<1|1,mid+1,R));
    }
    void cover(int l,int r,int x,int L,int R,uint val){
        if(L<=l&&r<=R){
            adjust(x,val);
            return;
        }
        down(x);
        int mid=l+r>>1;
        if(L<=mid)cover(l,mid,x<<1,L,R,val);
        if(R>mid)cover(mid+1,r,x<<1|1,L,R,val);
        up(x);
    }
    void build(int l,int r,int x){
//      v[x].flag=0;//
        if(l==r){
            v[x].mn=key[dfsID[l]];
            return;
        }
        int mid=l+r>>1;
        build(l,mid,x<<1);
        build(mid+1,r,x<<1|1);
        up(x);
    }
}sgm;

//-----------------------------
template<class T>void rd(T &x){
    x=0;char c;
    while(c=getchar(),c<48);
    do x=x*10+(c^48);
    while(c=getchar(),c>47);
}
template<class T>void nt(T x){
    if(!x)return;
    nt(x/10);
    putchar(x%10+'0');
}
template<class T>void pt(T x){
    if(!x)putchar('0');
    else nt(x);
    putchar('\n');
}
//------------------------------

void update(int u,int v,int s){
    while(link[u]!=link[v]){
        if(dep[link[u]]<dep[link[v]])swap(u,v);
        sgm.cover(1,n,1,lx[link[u]],lx[u],s);//
        u=nxt[link[u]][0];
    }
    if(dep[u]<dep[v])swap(u,v);
    sgm.cover(1,n,1,lx[v],lx[u],s);//
}

void query(int u){
    if(u==Rt){
        pt(sgm.query(1,n,1,1,n));
        return;
    }
    if(lx[Rt]<lx[u]||rx[u]<lx[Rt]){
        pt(sgm.query(1,n,1,lx[u],rx[u]));
        return;
    }
    int rt=getup(Rt,dep[Rt]-dep[u]-1);
    uint res=sgm.query(1,n,1,1,lx[rt]-1);
    if(rx[rt]!=n)res=min(res,sgm.query(1,n,1,rx[rt]+1,n));
    pt(res);
}

int main(){
    rd(n);rd(m);
    for(int u,v,i=1;i<n;i++){
        rd(u);rd(v);
        ins(u,v);
        ins(v,u);
    }
    for(int i=1;i<=n;i++)
        rd(key[i]);
    //input

    dfs(1,0);
    assign(1,1);
    rd(Rt);
    //prepare

    sgm.build(1,n,1);
    uint s;
    for(int opt,u,v,i=1;i<=m;i++){
        rd(opt);
        if(opt==1)rd(Rt);
        if(opt==2){
            rd(u);rd(v);rd(s);
            update(u,v,s);
        }
        if(opt==3){
            rd(u);
            query(u);
        }
    }
    //solve
    return 0;
}