BZOJ3306: 树

n<=1e5的有根点权树，m<=1e5个操作：换根，修改点权，查询子树最小值。

维护子树信息--dfs序，至于换根只需要分类讨论一下现在根和查询点的关系。

如果查询的点是根节点，就输出整颗树的最小值。

如果查询的点5在1到7的路径上，那以7为根的时候查询5，就是整颗树排除粉红色部分--5的儿子中，是7的祖先的那棵子树，就是5的儿子中能走到7的那一个对应的子树。

其他情况，直接输出查询的子树。

所以再写一个lca就行了，这里写了链剖可以顺便把dfs序搞出来。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
//#include<assert.h>
#include<math.h>
#include<algorithm>
//#include<iostream>
using namespace std;
 
int n,m;
#define maxn 200011
struct Edge{int to,next;}edge[maxn<<1];int first[maxn],val[maxn],le=2;
void in(int x,int y) {Edge &e=edge[le];e.to=y;e.next=first[x];first[x]=le++;}
void insert(int x,int y) {in(x,y);in(y,x);}
int size[maxn],hea[maxn],fa[maxn],top[maxn],dep[maxn],list[maxn],lp[maxn],rp[maxn],ll;
void dfs1(int x,int f)
{
    fa[x]=f;dep[x]=dep[f]+1;
    size[x]=1;hea[x]=0;
    for (int i=first[x];i;i=edge[i].next)
    {
        const Edge &e=edge[i];if (e.to==f) continue;
        dfs1(e.to,x);
        size[x]+=size[e.to];
        if (size[hea[x]]<size[e.to]) hea[x]=e.to;
    }
}
void dfs2(int x,int from)
{
    top[x]=from;
    list[++ll]=x;lp[x]=ll;
    if (hea[x]) dfs2(hea[x],from);
    for (int i=first[x];i;i=edge[i].next)
    {
        const Edge &e=edge[i];if (e.to==hea[x] || e.to==fa[x]) continue;
        dfs2(e.to,e.to);
    }
    rp[x]=ll;
}
void treecut()
{
    dep[0]=fa[0]=size[0]=ll=0;
    dfs1(1,0);
    dfs2(1,1);
}
int lca(int x,int y)
{
    while (top[x]!=top[y])
    {
        if (dep[top[x]]<dep[top[y]]) {int t=x;x=y;y=t;}
        x=fa[top[x]];
    }
    return dep[x]<dep[y]?x:y;
}
int findimp(int x,int y)
{
    int last;
    while (top[x]!=top[y])
    {
        last=top[y];
        y=fa[top[y]];
    }
    if (x==y) return last;
    return list[lp[x]+1];
}
struct SMT
{
    struct Node
    {
        int Min;
        int l,r;
        int ls,rs;
    }a[maxn<<1];
    int size;
    SMT() {size=0;}
    void up(int x)
    {
        const int &p=a[x].ls,&q=a[x].rs;
        a[x].Min=min(a[p].Min,a[q].Min);
    }
    void build(int &x,int L,int R)
    {
        x=++size;
        a[x].l=L;a[x].r=R;
        if (L==R)
        {
            a[x].Min=val[list[L]];
            a[x].ls=a[x].rs=0;
        }
        else
        {
            const int mid=(L+R)>>1;
            build(a[x].ls,L,mid);
            build(a[x].rs,mid+1,R);
            up(x);
        }
    }
    void build() {int x;build(x,1,n);}
    int ql,qr,v;
    void be(int x)
    {
        if (a[x].l==a[x].r && a[x].l==ql) {a[x].Min=v;return;}
        const int mid=(a[x].l+a[x].r)>>1;
        if (ql<=mid) be(a[x].ls);
        else be(a[x].rs);
        up(x);
    }
    void be(int x,int v)
    {
        ql=x;this->v=v;
        be(1);
    }
    int query(int x)
    {
        if (ql<=a[x].l && a[x].r<=qr) return a[x].Min;
        const int mid=(a[x].l+a[x].r)>>1;
        int ans=0x3f3f3f3f;
        if (ql<=mid) ans=min(ans,query(a[x].ls));
        if (qr> mid) ans=min(ans,query(a[x].rs));
        return ans;
    }
    int query(int L,int R)
    {
        if (L>R) return 0x3f3f3f3f;
        ql=L;qr=R;
        return query(1);
    }
}t;
int nowroot;
int main()
{
    scanf("%d%d",&n,&m);
    int x,y;char s[3];
    memset(first,0,sizeof(first));
    for (int i=1;i<=n;i++)
    {
        scanf("%d%d",&x,&y);
        if (x) insert(x,i);
        val[i]=y;
    }
    treecut();
    t.build();
    nowroot=1;
    while (m--)
    {
        scanf("%s",s);
        if (s[0]=='E') scanf("%d",&nowroot);
        else if (s[0]=='V') scanf("%d%d",&x,&y),t.be(lp[x],y);
        else if (s[0]=='Q')
        {
            scanf("%d",&x);
            if (x==nowroot) printf("%d
",t.query(1,n));
            else
            {
                int l=lca(x,nowroot);
                if (l==nowroot || (l!=x && l!=nowroot)) printf("%d
",t.query(lp[x],rp[x]));
                else
                {
                    int tmp=findimp(x,nowroot);
                    printf("%d
",min(t.query(1,lp[tmp]-1),t.query(rp[tmp]+1,n)));
                }
            }
        }
    }
    return 0;
}