BZOJ 3083 遥远的国度 (树链剖分 + 换根讨论)

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

问题是这样的：遥远的国度有 $n$ 个城市，这些城市之间由一些路连接且这些城市构成了一颗树。这个国度有一个首都，我们可以把这个首都看做整棵树的根，但遥远的国度比较奇怪，首都是随时有可能变为另外一个城市的。遥远的国度的每个城市有一个防御值，第 $i$ 个的防御值为 $va{l}_i$，有些时候 RapiD 会使得某两个城市之间的路径上的所有城市的防御值都变为某个值。

RapiD 想知道在某个时候，如果把首都看做整棵树的根的话，那么以某个城市为根的子树的所有城市的防御值最小是多少。

由于 RapiD 无法解决这个问题，所以他拦住了 zcwwzdjn 希望他能帮忙。但 zcwwzdjn 还要追杀 zhx，所以这个重大的问题就被转交到了你的手上。

Input
第 $1$ 行两个整数 $nm$，代表城市个数和操作数。

第 $2$ 行至第 $n$ 行，每行两个整数 $uv$，代表城市 $u$ 和城市 $v$ 之间有一条路。

第 $n+1$ 行，有 $n$个整数，第 $i$ 个代表第 $i$ 个点的初始防御值 $va{l}_i$ 。

第 $n+2$ 行一个整数$id$，代表初始的首都为 $id$。

第 $n+3$ 行至第 $n+m+2$ 行，首先有一个整数 $opt$。

如果 $opt=1$，接下来有一个整数 $id$，代表把首都修改为$id$；

如果 $opt=2$，接下来有三个整数 $x,y,v$，代表将 $x,y,v$ 路径上的所有城市的防御值修改为 $v$；

如果 $opt=3$，接下来有一个整数 $id$，代表询问以城市 $id$ 为根的子树中的最小防御值。

$1\le n\le 100000,1\le m\le 100000,0<va{l}_i\le 2^{31}$

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

Examples
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

output
1
2
3
4

Solution
如果没有换根的操作，显然就是裸的树剖。
考虑换根：
先以1为根剖一遍树
假设现在的根为rt，此次查询点u的子树最小值
① u == rt ：res = t[1].minn
② rt 不在 u 以1 为根节点时的子树中： 无影响，和以1为根节点的情况下的答案一样
③ rt 在 u 以 1 为根节点的子树中 ：
在以1为根节点的情况下，我们从节点u的所有儿子中找到儿子x ，使得节点rt 在节点x 的子树中
显然，此时在以rt 为根节点的情况下，节点u的子树即 除去节点x的子树(以1为根)的所有元素

很多题解采用LCA来判断情况③，但其实只需要利用dfs序下子树的节点编号连续这个性质即可很容易实现

Hint
这题思路其实很容易想出，但被INF不够大卡了半天…
另：题目所给数据范围好像爆了int… 但洛谷没有卡的数据

若题目要求维护子树和也是相同的处理方式
Code

#include <bits/stdc++.h>
#define ls rt << 1
#define rs rt << 1 | 1
using namespace std;

typedef long long ll;
const int INF = 2e9;
const int maxn = 1e6 + 7;
int n,m,root;
int ecnt,head[maxn],w[maxn],wt[maxn];
struct Edge{
    int v,next;
}e[maxn << 1];

void add(int u,int v){
    e[++ecnt].v = v, e[ecnt].next = head[u], head[u] = ecnt;
    e[++ecnt].v = u, e[ecnt].next = head[v], head[v] = ecnt;
}

struct Segtree{
    int l,r,minn,lazy;
}t[maxn << 3];

void push_up(int rt){
    t[rt].minn = min(t[ls].minn, t[rs].minn);
}

void build(int rt,int l,int r){
    t[rt].l = l, t[rt].r = r;
    t[rt].lazy = -1;
    if(l == r){t[rt].minn = wt[l];return ;}
    int mid = (l + r) >> 1;
    build(ls,l,mid);build(rs,mid+1,r);
    push_up(rt);
}

void push_down(int rt){
    if(t[rt].lazy != -1){
        int k = t[rt].lazy;
        t[ls].minn = t[ls].lazy = t[rs].minn = t[rs].lazy = k;
        t[rt].lazy = -1;
    }
}

void update(int rt,int L,int R,int k){
    int l = t[rt].l, r = t[rt].r;
    if(L <= l && r <= R){
        t[rt].minn = t[rt].lazy = k;
        return ;
    }
    push_down(rt);
    int mid = (l + r) >> 1;
    if(L <= mid) update(ls,L,R,k);
    if(R  > mid) update(rs,L,R,k);
    push_up(rt);
}

int query(int rt,int L,int R){
    int l = t[rt].l, r = t[rt].r;
    if(L > R || l > R || r < L) return INF;
    if(L <= l && r <= R) return t[rt].minn;
    int mid = (l + r) >> 1, res = INF;
    push_down(rt);
    if(L <= mid) res = min(res,query(ls,L,R));
    if(R  > mid) res = min(res,query(rs,L,R));
    return res;
}

int cnt,siz[maxn],top[maxn],dep[maxn],son[maxn],fa[maxn],id[maxn];

void dfs1(int u,int f,int deep){
    siz[u] = 1, dep[u] = deep, fa[u] = f;
    int maxson = -1;
    for(int i = head[u];i;i = e[i].next){
        int v = e[i].v;if(v == f) continue;
        dfs1(v,u,deep+1);
        siz[u] += siz[v];
        if(siz[v] > maxson){maxson = siz[v]; son[u] = v;}
    }
}

void dfs2(int u,int topf){
    top[u] = topf, id[u] = ++cnt, wt[cnt] = w[u];
    if(!son[u]) return ;
    dfs2(son[u],topf);
    for(int i = head[u];i;i = e[i].next){
        int v = e[i].v;if(v == son[u] || v == fa[u]) continue;
        dfs2(v,v);
    }
}

void updRange(int u,int v,int k){
    while(top[u] != top[v]){
        if(dep[top[u]] < dep[top[v]]) swap(u,v);
        update(1,id[top[u]],id[u],k);
        u = fa[top[u]];
    }
    if(dep[u] > dep[v]) swap(u,v);
    update(1,id[u],id[v],k);
}


int qson(int u){
    if(u == root) return t[1].minn;
    else if(id[root] < id[u] || id[root] > id[u] + siz[u] - 1){
        return query(1,id[u],id[u] + siz[u] - 1);
    } else{
        int tmp = 0;
        for(int i = head[u];i;i = e[i].next){
            int v = e[i].v;if(v == fa[u]) continue;
            int L = id[v], R = id[v] + siz[v] - 1;
            if(L <= id[root] && id[root] <= R) {tmp = v;break;}
        }
        //除去以tmp为根的子树
        int res = min(query(1,1,id[tmp]-1), query(1,id[tmp] + siz[tmp],n));
        return res;
    }
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i = 1;i < n;++i){
        int u,v;scanf("%d%d",&u,&v);add(u,v);
    }
    for(int i = 1;i <= n;++i) scanf("%d",&w[i]);
    scanf("%d",&root);
    dfs1(1,-1,1);dfs2(1,1);build(1,1,n);
    while(m--){
        int op;scanf("%d",&op);
        if(op == 1) {int x;scanf("%d",&x);root = x;}
        if(op == 2) {int x,y,v;scanf("%d%d%d",&x,&y,&v);updRange(x,y,v);}
        if(op == 3) {int x;scanf("%d",&x);printf("%d\n", qson(x));}
    }
    return 0;
}