POJ 3237 Tree (树链剖分 路径剖分 线段树的lazy标记)

题目链接：http://poj.org/problem?id=3237

一棵有边权的树，有3种操作。

树链剖分+线段树lazy标记。lazy为0表示没更新区间或者区间更新了2的倍数次，1表示为更新，每次更新异或1就可以。

熟悉线段树成段更新就很简单了，最初姿势不对一直wa，还是没有彻底理解lazy标记啊。

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int MAXN = 1e4 + 5;
struct EDGE {
    int next , to , cost;
}edge[MAXN << 1];
int head[MAXN] , tot;
int par[MAXN] , size[MAXN] , son[MAXN] , dep[MAXN];
int top[MAXN] , id[MAXN] , cnt;
int from[MAXN] , to[MAXN] , cost[MAXN];

void init() {
    tot = cnt = 0;
    memset(head , -1 , sizeof(head));
}

inline void add(int u , int v , int cost) {
    edge[tot].next = head[u];
    edge[tot].to = v;
    head[u] = tot++;
}

void dfs1(int u , int p , int d) {
    par[u] = p , size[u] = 1 , son[u] = u , dep[u] = d;
    for(int i = head[u] ; ~i ; i = edge[i].next) {
        int v = edge[i].to;
        if(v == p)
            continue;
        dfs1(v , u , d + 1);
        if(size[v] >= size[son[u]])
            son[u] = v;
        size[u] += size[v];
    }
}

void dfs2(int u , int p , int t) {
    top[u] = t , id[u] = ++cnt;
    if(son[u] != u)
        dfs2(son[u] , u , t);
    for(int i = head[u] ; ~i ; i = edge[i].next) {
        int v = edge[i].to;
        if(v == p || v == son[u])
            continue;
        dfs2(v , u , v);
    }
}

struct SegTree {
    int l , r , Max , lazy , Min; //lazy变量0表示无更新 1表示有更新
}T[MAXN << 2];

void build(int p , int l , int r) {
    int mid = (l + r) >> 1;
    T[p].l = l , T[p].r = r , T[p].lazy = 0;
    if(l == r) {
        return ;
    }
    build(p << 1 , l , mid);
    build((p << 1)|1 , mid + 1 , r);
}

void pushup(int p) {
    if(T[p].lazy) {
        int ls = p << 1 , rs = (p << 1)|1;
        T[ls].lazy ^= 1;
        T[rs].lazy ^= 1;
        
        int temp;
        temp = T[ls].Max;
        T[ls].Max = -T[ls].Min;
        T[ls].Min = -temp;

        temp = T[rs].Max;
        T[rs].Max = -T[rs].Min;
        T[rs].Min = -temp;
        T[p].lazy = 0;
    }    
}
//更新操作就是 将原来的Max变成-Min ，Min变成-Max
void updata(int p , int l , int r , int flag) {
    int mid = (T[p].r + T[p].l) >> 1;
    if(T[p].l == l && T[p].r == r) {
        T[p].lazy ^= flag;
        int temp = T[p].Max;
        T[p].Max = -T[p].Min;
        T[p].Min = -temp;
        return ;
    }
    pushup(p);
    if(r <= mid) {
        updata(p << 1 , l , r , flag);
    }
    else if(l > mid) {
        updata((p << 1)|1 , l , r , flag);
    }
    else {
        updata(p << 1 , l , mid , flag);
        updata((p << 1)|1 , mid + 1 , r , flag);
    }
    T[p].Max = max(T[p << 1].Max , T[(p << 1)|1].Max);
    T[p].Min = min(T[p << 1].Min , T[(p << 1)|1].Min);
}

int query(int p , int l , int r) {
    int mid = (T[p].l + T[p].r) >> 1;
    if(T[p].l == l && T[p].r == r) {
        return T[p].Max;
    }
    pushup(p);
    if(r <= mid) {
        return query(p << 1 , l , r);
    }
    else if(l > mid) {
        return query((p << 1)|1 , l , r);
    }
    else {
        return max(query(p << 1 , l , mid) , query((p << 1)|1 , mid + 1 , r));
    }
}

void updata_pos(int p , int pos , int num) {
    int mid = (T[p].l + T[p].r) >> 1;
    if(T[p].l == T[p].r && T[p].l == pos) {
        T[p].Max = T[p].Min = num;
        T[p].lazy = 0;
        return ;
    }
    pushup(p);
    if(pos <= mid) {
        updata_pos(p << 1 , pos , num);
    }
    else {
        updata_pos((p << 1)|1 , pos , num);
    }
    T[p].Max = max(T[p << 1].Max , T[(p << 1)|1].Max);
    T[p].Min = min(T[p << 1].Min , T[(p << 1)|1].Min);
}

int find_max(int u , int v) {
    int fu = top[u] , fv = top[v] , Max = -99999999;
    while(fv != fu) {
        if(dep[fu] > dep[fv]) {
            Max = max(Max , query(1 , id[fu] , id[u]));
            u = par[fu];
            fu = top[u];
        }
        else {
            Max = max(Max , query(1 , id[fv] , id[v]));
            v = par[fv];
            fv = top[v];
        }
    }
    if(v == u)
        return Max;
    else if(dep[u] > dep[v])
        return max(Max , query(1 , id[son[v]] , id[u]));
    else
        return max(Max , query(1 , id[son[u]] , id[v]));
}

void change(int u , int v) {
    int fu = top[u] , fv = top[v];
    while(fu != fv) {
        if(dep[fu] > dep[fv]) {
            updata(1 , id[fu] , id[u] , 1);
            u = par[fu];
            fu = top[u];
        }
        else {
            updata(1 , id[fv] , id[v] , 1);
            v = par[fv];
            fv = top[v];
        }
    }
    if(v == u)
        return ;
    else if(dep[u] > dep[v])
        updata(1 , id[son[v]] , id[u] , 1);
    else
        updata(1 , id[son[u]] , id[v] , 1);
}

int main() 
{
    int t, n;
    scanf("%d", &t);
    while(t--) {
        init();
        scanf("%d" , &n);
        for(int i = 1 ; i < n ; ++i) {
            scanf("%d %d %d" , from + i , to + i , cost + i);
            add(from[i] , to[i] , cost[i]);
            add(to[i] , from[i] , cost[i]);
        }
        dfs1(1 , 1 , 0);
        dfs2(1 , 1 , 1);
        build(1 , 2 , cnt);
        for(int i = 1 ; i < n ; ++i) {
            if(dep[from[i]] < dep[to[i]])
                swap(from[i] , to[i]);
            updata_pos(1 , id[from[i]] , cost[i]);
        }
        char q[10];
        int l , r;
        while(scanf("%s" , q) && q[0] != 'D') {
            scanf("%d %d" , &l , &r);
            if(q[0] == 'Q') {
                printf("%d
" , find_max(l , r));
            }
            else if(q[0] == 'N') {
                change(l , r);
            }
            else {
                updata_pos(1 , id[from[l]] , r);
            }
        }
    }
    return 0;
}