BZOJ 3083

原题地址：http://www.lydsy.com/JudgeOnline/problem.php?id=3083

说话间又一个多月过去了。。该来除除草了，每天都是训练、没效率，训练、没效率。。省选考得不好不说了=-继续努力吧

题目大意：维护一棵有根树，支持三个操作：换根; 一条链上都改为一个值; 求某个子树的Min

算法分析：
裸的动态树问题，非常简单啦。只涉及链上和子树操作，树的形态没有改变，所以用剖分来搞。就按照最开始给定的那个根剖分，得到一个剖分序。在换根之后查子树的时候注意一件事情，就是在最早的定根的形态中，现在的根如果在要查询的那个子树的根的某个儿子的子树上的话，就需要查询整个树除去这个儿子的子树的最小值，否则就是原来的那个子树的最小值。至于怎么判断，我用剖分序乱搞的=-

参考代码：

//date 20140521
#include <cstdio>
#include <cstring>

const int maxn = 105000;
const int INF = 0x7FFFFFFF;

template <typename T> inline void swap(T &a, T &b){T x = a; a = b; b = x;}
inline int innew(int &a, int b){if(a < b){a = b; return 1;} return 0;}
inline int denew(int &a, int b){if(a > b){a = b; return 1;} return 0;}
inline int min(int a, int b){return a < b ? a : b;}

inline int getint()
{
    int ans(0); char w = getchar();
    while(w < '0' || '9' < w) w = getchar();
    while('0' <= w && w <= '9')
    {
        ans = ans * 10 + w - '0';
        w = getchar();
    }
    return ans;
}

int n, m, root;
struct edge
{
    int v, next;
}E[maxn << 1];
int nedge, a[maxn], num[maxn];

inline void add(int u, int v)
{
    E[++nedge].v = v;
    E[nedge].next = a[u];
    a[u] = nedge;
}

int dpt[maxn], p[maxn], size[maxn], hp[maxn], hs[maxn];
int order[maxn], ps[maxn], ped[maxn];

inline void dfs_one(int v0)
{
    static int d[maxn], now[maxn];
    int last, i, j;
    memcpy(now, a, sizeof a);
    d[last = dpt[v0] = size[v0] = 1] = v0;
    while(last)
    {
        if(!(j = now[i = d[last]]))
        {
            if((--last) && (size[d[last]] += size[i], size[hs[d[last]]] < size[i]))
                hs[d[last]] = i;
            continue;
        }
        if(p[i] != E[j].v) dpt[d[++last] = E[j].v] = dpt[p[E[j].v] = i] + (size[E[j].v] = 1);
        now[i] = E[j].next;
    }
}

inline void dfs_two(int v0)
{
    static int d[maxn], now[maxn];
    int last, i, j, tot;
    d[last = 1] = order[ps[v0] = ped[v0] = tot = 1] = v0;
    memset(now, 0xFF, sizeof now);
    for(int i = 1; i <= n; ++i) hp[i] = i;
    while(last)
    {
        if(!(j = now[i = d[last]]))
        {
            if(--last) innew(ped[d[last]], ped[i]);
            continue;
        }
        if(j == -1)
        {
            if(hs[i]) hp[d[++last] = order[ps[hs[i]] = ped[hs[i]] = ++tot] = hs[i]] = hp[i];
            now[i] = a[i]; continue;
        }
        if(E[j].v != hs[i] && E[j].v != p[i]) d[++last] = order[ps[E[j].v] = ped[E[j].v] = ++tot] = E[j].v;
        now[i] = E[j].next;
    }
}

struct Segment_Tree
{
    struct node
    {
        node *s[2];
        int l, r, Min, cov;
        node(){}
        int cover(int v){Min = v; cov = 1;}
        void pushdown()
        {
            if(cov && l < r){s[0]->cover(Min); s[1]->cover(Min);}
            cov = 0; 
        }
        void update(){ Min = min(s[0]->Min, s[1]->Min);}
    }*root, pond[maxn << 1];
    int stop;
    
    void change(node *p, int l, int r, int v)
    {
        if(l <= p->l && p->r <= r){p->cover(v); return;}
        p->pushdown();
        int mid = (p->l + p->r) >> 1;
        if(l <= mid) change(p->s[0], l, r, v);
        if(r >  mid) change(p->s[1], l, r, v);
        p->update();
    }
    
    int query(node *p, int l, int r)
    {
        if(l <= p->l && p->r <= r){return p->Min;}
        p->pushdown();
        int mid = (p->l + p->r) >> 1;
        int ans = INF;
        if(l <= mid) denew(ans, query(p->s[0], l, r));
        if(r >  mid) denew(ans, query(p->s[1], l, r));
        return ans;
    }
    
    node *build(int l, int r)
    {
        node *p = &pond[stop++];
        p->s[0] = p->s[1] = NULL; p->cov = 0; p->l = l; p->r = r;
        if(l == r) {p->Min = num[order[l]]; return p;}
        int mid = (l + r) >> 1;
        p->s[0] = build(l, mid);
        p->s[1] = build(mid + 1, r);
        p->update();
        return p;
    }
    
    void preset(){stop = 0; root = build(1, n);}
    
    int get_min(int l, int r)
    {
        if(l > r) swap(l, r);
        return query(root, l, r);
    }
    
    void change(int l, int r, int v)
    {
        if(l > r) swap(l, r);
        change(root, l, r, v);
    }
}MEOW;

inline void reroot(int r){root = r;}
inline void change(int x, int y, int v)
{
    int x0 = x, y0 = y;
    while(hp[x0] != hp[y0])
    {
        if(dpt[hp[x0]] > dpt[hp[y0]])
        {
            MEOW.change(ps[hp[x0]], ps[x0], v);
            x0 = p[hp[x0]];
        }else{
            MEOW.change(ps[hp[y0]], ps[y0], v);
            y0 = p[hp[y0]];
        }
    }
    MEOW.change(ps[x0], ps[y0], v);
}
inline int query(int x)
{
    if(x == root) return MEOW.root->Min;
    int x0 = x, r = root, sgn = 1, tp = 0;
    if(hp[x0] == hp[r] && dpt[r] > dpt[x]) sgn = 0;
    while(hp[x0] != hp[r])
    {
        if(dpt[hp[x0]] > dpt[hp[r]]) {sgn = 1; break;}
        if(p[hp[r]] == x0) tp = hp[r];
        sgn = 0; r = p[hp[r]];
    }
    if(dpt[r] < dpt[x]) sgn = 1;
    if(sgn) return MEOW.get_min(ps[x], ped[x]);
    if(r != x0) tp = hs[x0];
    int ans = MEOW.get_min(1, ps[tp] - 1);
    if(ped[tp] != n) denew(ans, MEOW.get_min(ped[tp] + 1, n));
    return ans;
}

int main()
{
    freopen("bzoj.in", "r", stdin);
    freopen("bzoj.out", "w", stdout);
    
    n = getint(); m = getint();
    for(int i = 1; i < n; ++i)
    {
        int x = getint(), y = getint();
        add(x, y); add(y, x);
    }
    for(int i = 1; i <= n; ++i) num[i] = getint() - 1;
    root = getint();
    dfs_one(root); dfs_two(root);
    MEOW.preset();
    for(int i = 1; i <= m; ++i)
    {
        int k, x, y, v;
        k = getint();
        switch(k)
        {
            case 1: x = getint(); reroot(x); break;
            case 2: x = getint(); y = getint(); v = getint() - 1; change(x, y, v); break;
            case 3: x = getint(); printf("%u
", (unsigned)query(x) + 1u); break;
        }
    }
    return 0;
}