BZOJ 3083: 遥远的国度 树链剖分，处理树的换根

Description

描述
zcwwzdjn在追杀十分sb的zhx，而zhx逃入了一个遥远的国度。当zcwwzdjn准备进入遥远的国度继续追杀时，守护神RapiD阻拦了zcwwzdjn的去路，他需要zcwwzdjn完成任务后才能进入遥远的国度继续追杀。

问题是这样的：遥远的国度有n个城市，这些城市之间由一些路连接且这些城市构成了一颗树。这个国度有一个首都，我们可以把这个首都看做整棵树的根，但遥远的国度比较奇怪，首都是随时有可能变为另外一个城市的。遥远的国度的每个城市有一个防御值，有些时候RapiD会使得某两个城市之间的路径上的所有城市的防御值都变为某个值。RapiD想知道在某个时候，如果把首都看做整棵树的根的话，那么以某个城市为根的子树的所有城市的防御值最小是多少。由于RapiD无法解决这个问题，所以他拦住了zcwwzdjn希望他能帮忙。但zcwwzdjn还要追杀sb的zhx，所以这个重大的问题就被转交到了你的手上。

Input

第1行两个整数n m，代表城市个数和操作数。
第2行至第n行，每行两个整数 u v，代表城市u和城市v之间有一条路。
第n+1行，有n个整数，代表所有点的初始防御值。
第n+2行一个整数 id，代表初始的首都为id。
第n+3行至第n+m+2行，首先有一个整数opt，如果opt=1，接下来有一个整数id，代表把首都修改为id；如果opt=2，接下来有三个整数p1 p2 v，代表将p1 p2路径上的所有城市的防御值修改为v；如果opt=3，接下来有一个整数 id，代表询问以城市id为根的子树中的最小防御值。
Output

对于每个opt=3的操作，输出一行代表对应子树的最小点权值。
Sample Input
3 7

1 2

1 3

1 2 3

1

3 1

2 1 1 6

3 1

2 2 2 5

3 1

2 3 3 4

3 1

Sample Output
1

2

3

4

提示

对于20%的数据，n<=1000 m<=1000。

对于另外10%的数据，n<=100000，m<=100000，保证修改为单点修改。

对于另外10%的数据，n<=100000，m<=100000，保证树为一条链。

对于另外10%的数据，n<=100000，m<=100000，没有修改首都的操作。

对于100%的数据，n<=100000，m<=100000，0<所有权值<=2^31。

解法：

子树操作，链上修改，带size域的树链剖分就可以搞定。换根肯定不能真的换，出题人要是闲的没事所有操作都在换根就惨。我们可以

画一张图模拟下换根。先按照读入的顺序建一颗有根树，然后观察当前的根在要询问的点的位置。如果当前的根在要询问的点的儿子

中，那么那个点为根的时候，当前点的子树就是除了当前点的有根节点的子树的点意外的所有点。如果根不在当前点的子树中，那么当

前点的子树不变。还有一种情况要特殊讨论一下，当前点就是根，那么子树就是整棵树。

PS：一个点的子树的范围是pos[x]~pos[x] + size[x] - 1

///BZOJ 3083

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct edge{int v,next;}E[maxn*2];
struct seg{int l,r,cover,minn;}tree[maxn*4];
int n,m,tot,edgecnt,tim, root;
int num[maxn],siz[maxn],top[maxn],son[maxn],dep[maxn],tid[maxn],fa[maxn],head[maxn];
void init(){
    memset(head,-1,sizeof(head));
    memset(son,-1,sizeof(son));
    edgecnt=tim=0;
}
void addedge(int u, int v){
    E[edgecnt].v=v,E[edgecnt].next=head[u],head[u]=edgecnt++;
}
void dfs1(int u, int father, int d){
    dep[u]=d;
    fa[u]=father;
    siz[u]=1;
    for(int i=head[u];~i;i=E[i].next){
        int v=E[i].v;
        if(v==father) continue;
        dfs1(v,u,d+1);
        siz[u]+=siz[v];
        if(son[u]==-1||siz[v]>siz[son[u]]) son[u]=v;
    }
}
void dfs2(int u, int tp){
    top[u]=tp;
    tid[u]=++tim;
    if(son[u]==-1) return;
    dfs2(son[u],tp);
    for(int i=head[u];~i;i=E[i].next){
        int v=E[i].v;
        if(v!=son[u]&&v!=fa[u]) dfs2(v,v);
    }
}
bool check(int x, int f){
    if(tid[x]<tid[f]||tid[x]>tid[f]+siz[f]-1) return false;
    return true;
}
void pushup(int rt){
    tree[rt].minn=min(tree[rt*2].minn,tree[rt*2+1].minn);
}
void pushdown(int rt){
    if(tree[rt].cover){
        tree[rt*2].minn=tree[rt*2+1].minn=tree[rt].cover;
        tree[rt*2].cover=tree[rt*2+1].cover=tree[rt].cover;
        tree[rt].cover=0;
    }
}
void build(int l, int r, int rt){
    tree[rt].l=l,tree[rt].r=r;
    if(l==r) return;
    int mid=(l+r)/2;
    build(l,mid,rt*2);
    build(mid+1,r,rt*2+1);
}
void update(int L, int R, int c, int rt){
    if(L==tree[rt].l&&tree[rt].r==R){
        tree[rt].minn=c;
        tree[rt].cover=c;
        return;
    }
    pushdown(rt);
    int mid=(tree[rt].l+tree[rt].r)/2;
    if(R<=mid) update(L,R,c,rt*2);
    else if(L>mid) update(L,R,c,rt*2+1);
    else{
        update(L,mid,c,rt*2);
        update(mid+1,R,c,rt*2+1);
    }
    pushup(rt);
}
void change(int x, int y, int c){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        update(tid[top[x]], tid[x], c, 1);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y]) swap(x,y);
    update(tid[x],tid[y],c,1);
}
int query(int L, int R, int rt){
    if(L==tree[rt].l&&tree[rt].r==R){
        return tree[rt].minn;
    }
    pushdown(rt);
    int mid=(tree[rt].l+tree[rt].r)/2;
    if(R<=mid) return query(L,R,rt*2);
    else if(L>mid) return query(L,R,rt*2+1);
    else return min(query(L,mid,rt*2),query(mid+1,R,rt*2+1));
}

int main(){
    scanf("%d%d", &n,&m);
    init();
    for(int i=1; i<n; i++){
        int x,y;
        scanf("%d%d", &x,&y);
        addedge(x,y);
        addedge(y,x);
    }
    dfs1(1,1,1);
    dfs2(1,1);
    build(1,n,1);
    for(int i=1; i<=n; i++){
        int x;
        scanf("%d", &x);
        update(tid[i],tid[i],x,1);
    }
    scanf("%d", &root);
    for(int i=1; i<=m; i++){
        int op,x,y,z;
        scanf("%d", &op);
        if(op==1) scanf("%d", &root);
        if(op==2){
            scanf("%d%d%d", &x,&y,&z);
            change(x,y,z);
        }
        if(op==3){
            scanf("%d", &x);
            if(x==root){
                printf("%d\n", tree[1].minn);
            }
            else{
                int Son=0;
                for(int j=head[x];~j&&!Son;j=E[j].next){
                    int v=E[j].v;
                    if(v==fa[x]) continue;
                    if(check(root,v)) Son=v;
                }
                if(Son){
                    int LL = query(1,tid[Son]-1,1);
                    int RR = __INT_MAX__;
                    if(tid[Son]+siz[Son]<=n){
                        RR = query(tid[Son]+siz[Son],n,1);
                    }
                    int ans = query(tid[x], tid[x], 1);
                    ans = min(ans,min(LL,RR));
                    printf("%d\n", ans);
                }
                else{
                    printf("%d\n", query(tid[x],tid[x]+siz[x]-1,1));
                }
            }
        }
    }
    return 0;
}