[BZOJ3083]遥远的国度-树链剖分-线段树

遥远的国度

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。

---

震惊！zz选手做大水题4RE的真相竟然是……
竟然是zz选手忘记特判导致出现查询区间l>r的情况……

(╯‵□′)╯︵┻━┻

---

思路:
题目叫咱换根。
但是，怎么能题目叫你干什么就干什么呢？？
所以显然咱不打算换。

那么，如果抛开换根问题，这就是一个很裸的树链剖分+线段树了。
有了换根怎么办？

显然这对修改操作无丝毫影响。
那么对于询问操作，考虑分类讨论:
如果当前根节点就是询问节点，查询对象为整棵树。
如果当前根节点与询问节点的LCA不是询问节点，那么这对询问节点的子树毫无影响，直接查询。
否则枚举询问节点的每个儿子，计算这个儿子与根的LCA是否为这个儿子本身，如果是，则在换根的情况下，这个儿子将会是询问节点的父亲，那么查询排除掉这个儿子的子树的剩余部分即可~
至于怎么查询最后一种情况，既然都树链剖分了，那么显然已经获得了了dfs序，1~儿子初始dfs序-1 和 儿子结束dfs序+1~n 这两个区间即为要查询的对象。
注意儿子初始dfs序为1和儿子结束dfs序为n的情况。
（4RE的罪恶根源……）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

#define yo puts("yo")
#define yoo puts("yoo")
#define yooo puts("yooo")

inline int read()
{
    int x=0;char ch=getchar();
    while(ch<'0' || '9'<ch)ch=getchar();
    while('0'<=ch && ch<='9')x=x*10+(ch^48),ch=getchar();
    return x;
}

const int N=100009;

int n,m;
int to[N<<1],nxt[N<<1],beg[N],tot;
int fa[N],top[N],siz[N],son[N],ed[N],dep[N];
int val[N],id[N],seg[N],t[N<<2],tag[N<<2],dfn;
int root;

inline void adde(int u,int v)
{
    to[++tot]=v;
    nxt[tot]=beg[u];
    beg[u]=tot;
}

inline void add(int u,int v)
{
    adde(u,v);
    adde(v,u);
}

inline void dfs(int u)
{
    siz[u]=1;
    son[u]=0;
    for(int i=beg[u],v;i;i=nxt[i])
        if((v=to[i])!=fa[u])
        {
            fa[v]=u;
            dep[v]=dep[u]+1;
            dfs(v);
            siz[u]+=siz[v];
            if(!son[u] || siz[son[u]]<siz[v])
                son[u]=v;
        }
}

inline void dfs2(int u)
{
    seg[++dfn]=u;
    id[u]=dfn;
    if(son[u])
    {
        top[son[u]]=top[u];
        dfs2(son[u]);
        for(int i=beg[u],v;i;i=nxt[i])
            if((v=to[i])!=fa[u] && v!=son[u])
                dfs2(top[v]=v);
    }
    ed[u]=dfn;
}

inline void upd(int x)
{
    t[x]=min(t[x<<1],t[x<<1|1]);
}

inline void push(int x)
{
    if(tag[x])
    {
        tag[x<<1]=tag[x<<1|1]=tag[x];
        t[x<<1]=t[x<<1|1]=tag[x];
        tag[x]=0;
    }
}

inline void biu(int x,int l,int r)
{
    if(l==r)
    {
        t[x]=val[seg[l]];
        return;
    }
    int mid=l+r>>1;
    biu(x<<1,l,mid);
    biu(x<<1|1,mid+1,r);
    upd(x);
}

inline void modify(int x,int l,int r,int dl,int dr,int val)
{
    if(dl==l && r==dr)
    {
        t[x]=val;
        tag[x]=val;
        return;
    }

    push(x);
    int mid=l+r>>1;
    if(dr<=mid)
        modify(x<<1,l,mid,dl,dr,val);
    else if(mid<dl)
        modify(x<<1|1,mid+1,r,dl,dr,val);
    else
    {
        modify(x<<1,l,mid,dl,mid,val);
        modify(x<<1|1,mid+1,r,mid+1,dr,val);
    }
    upd(x);
}

inline int query(int x,int l,int r,int dl,int dr)
{
    if(dl==l && dr==r)
        return t[x];

    push(x);
    int mid=l+r>>1;
    if(dr<=mid)
        return query(x<<1,l,mid,dl,dr);
    if(mid<dl)
        return query(x<<1|1,mid+1,r,dl,dr);
    return min(query(x<<1,l,mid,dl,mid),query(x<<1|1,mid+1,r,mid+1,dr));
}

inline void change(int a,int b,int v)
{
    while(top[a]!=top[b])
    {
        if(dep[top[a]]<dep[top[b]])
            swap(a,b);
        modify(1,1,dfn,id[top[a]],id[a],v);
        a=fa[top[a]];
    }
    if(dep[a]<dep[b])
        modify(1,1,dfn,id[a],id[b],v);
    else
        modify(1,1,dfn,id[b],id[a],v);
}

inline int lca(int a,int b)
{
    while(top[a]!=top[b])
    {
        if(dep[top[a]]<dep[top[b]])
            swap(a,b);
        a=fa[top[a]];
    }
    if(dep[a]<dep[b])
        return a;
    return b;
}

inline int ask(int a)
{
    if(a==root)
        return query(1,1,dfn,1,dfn);
    else if(lca(a,root)!=a)
        return query(1,1,dfn,id[a],ed[a]);
    else
    {
        for(int i=beg[a],v;i;i=nxt[i])
            if((v=to[i])!=fa[a] && lca(v,root)==v)
            {
                int ret=2147483647;
                if(id[v]!=1)
                    ret=min(ret,query(1,1,dfn,1,id[v]-1));
                if(ed[v]!=dfn)
                    ret=min(ret,query(1,1,dfn,ed[v]+1,dfn));
                return ret;
            }
    }
}

int main()
{
    n=read();
    m=read();

    for(int i=1;i<n;i++)
        add(read(),read());
    for(int i=1;i<=n;i++)
        val[i]=read();
    root=read();

    fa[1]=1;
    top[1]=1;
    dep[1]=1;
    dfs(1);
    dfs2(1);
    biu(1,1,dfn);

    for(int i=1,opt,a,b,c;i<=m;i++)
    {
        opt=read();
        if(opt==1)
            root=read();
        else if(opt==2)
        {
            a=read();
            b=read();
            c=read();
            change(a,b,c);
        }
        else
            printf("%d\n",ask(read()));
    }

    return 0;
}