POJ 3237 Tree （树链剖分）

题意：有一棵n个节点的树，现有以下三种操作：

1、修改第i条边的权值
2、将a到b的路径的权值取反
3、查询a到b路径上的最大权值

思路：典型的树链剖分，路径上的权值用线段树维护，用lazy标记，判断某个区间取反的次数，写个线段树的模板错了大半天，无语......

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
const int maxn = 1e5 + 100;
const int INF = 1e9;
using namespace std;

struct P {
    int to, w, num;
    P() {}
    P(int t, int w, int n) : to(t), w(w), num(n) {}
};
struct seg {
    int l, r, Max, Min;
    int ls, rs, flag;
} C[4 * maxn];
vector<P> G[maxn]; ///存储邻接边信息
int n, tree[maxn], nodecnt; ///重路径划分
int path_cnt, path_size[maxn];  ///重路径数量,路径大小
int fa[maxn], path_top[maxn]; ///父节点,路径顶点
int path_dep[maxn], sz[maxn]; ///路径深度，子树节点数量
int bot[maxn], bel[maxn]; ///有向边指向的节点，节点属于的重路径
int rk[maxn], w[maxn];  ///每个节点是第几个节点，边的权值
int T, x, y, a, b, c;
char cmd[10];

void init() {
    for(int i = 0; i < maxn; i++) {
        G[i].clear(); nodecnt = 0;
        fa[i] = path_size[i] = sz[i] = 0;
        rk[i] = path_dep[i] = tree[i] = 0;
    }
}

void add(int f, int t, int we, int num) {
    G[f].push_back(P(t, we, num));
    G[t].push_back(P(f, we, num));
    w[num] = we;
}

void dfs(int k, int dep) {
    sz[k] = 1; bel[k] = 0;
    int maxson = 0, j;
    for(int i = 0; i < G[k].size(); i++) {
        P p = G[k][i];
        if(p.to == fa[k]) continue;
        fa[p.to] = k; bot[p.num] = p.to;
        dfs(p.to, dep + 1);
        sz[k] += sz[p.to];
        if(sz[p.to] > maxson) {
            maxson = sz[p.to]; j = i;
        }
    }
    for(int i = 0; i < G[k].size(); i++) {
        P p = G[k][i];
        if(p.to == fa[k]) continue;
        if(i == j) {
            bel[k] = bel[p.to];
            rk[k] = rk[p.to] + 1;
        } else {
            int t = bel[p.to];
            path_dep[t] = dep + 1;
            path_size[t] = rk[p.to];
            path_top[t] = p.to;
        }
    }
    if(!bel[k]) {
        bel[k] = ++path_cnt;
        rk[k] = 1;
    }
}

void build(int node, int l, int r) {
    C[node].l = l; C[node].r = r;
    C[node].Max = -INF;
    C[node].Min = INF;
    C[node].flag = 0;
    if(r - l > 1) {
        C[node].ls = ++nodecnt;
        int mid = (l + r) >> 1;
        build(C[node].ls, l, mid);
        C[node].rs = ++nodecnt;
        build(C[node].rs, mid, r);
    }
}

void upnode(int o) {
    int c = C[o].Max;
    C[o].Max = -C[o].Min;
    C[o].Min = -c;
}

void pushdown(int o) {
    if(!C[o].flag) return ;
    int ls = C[o].ls, rs = C[o].rs;
    C[ls].flag += C[o].flag;
    C[rs].flag += C[o].flag;
    if(C[o].flag & 1) {
        upnode(ls); upnode(rs);
    }
    C[o].flag = 0;
}

void pushup(int o) {
    int ls = C[o].ls, rs = C[o].rs;
    int lag = C[ls].flag;
    int rag = C[rs].flag;
    C[o].Max = max(C[ls].Max, C[rs].Max);
    C[o].Min = min(C[ls].Min, C[rs].Min);
}

void change(int o, int ind, int data) {
    if(C[o].r - C[o].l == 1) {
        C[o].Max = C[o].Min = data;
        C[o].flag = 0;
        return ;
    }
    int mid = (C[o].l + C[o].r) >> 1;
    pushdown(o);
    if(ind < mid) change(C[o].ls, ind, data);
    else change(C[o].rs, ind, data);
    pushup(o);
}

void change2(int o, int l, int r) {
    if(C[o].l >= l && C[o].r <= r) {
        C[o].flag++;
        upnode(o);
        return ;
    }
    if(C[o].r <= l || C[o].l >= r) return ;
    int mid = (C[o].l + C[o].r) >> 1;
    pushdown(o);
    if(mid > l) change2(C[o].ls, l, r);
    if(mid <= r) change2(C[o].rs, l, r);
    pushup(o);
}

void update(int a, int b) {
    int x = bel[a], y = bel[b];
    while(x != y) {
        if(path_dep[x] > path_dep[y]) {
            change2(tree[x], rk[a], path_size[x] + 1);
            a = fa[path_top[x]];  x = bel[a];
        } else {
            change2(tree[y], rk[b], path_size[y] + 1);
            b = fa[path_top[y]];  y = bel[b];
        }
    }
    if(rk[a] == rk[b]) return ;
    int ra = rk[a], rb = rk[b];
    if(ra > rb) change2(tree[x], rb, ra);
    else change2(tree[x], ra, rb);
}

int ask(int o, int l, int r) {
    if(C[o].l >= l && C[o].r <= r) return C[o].Max;
    if(C[o].l >= r || C[o].r <= l) return -INF;
    pushdown(o);
    int p1 = ask(C[o].ls, l, r);
    int p2 = ask(C[o].rs, l, r);
    return max(p1, p2);
}

void work(int x, int y) { change(tree[bel[bot[x]]], rk[bot[x]], y); }

void prepare() {
    dfs(1, 0);
    int i = bel[1];
    path_dep[i] = 0;
    path_size[i] = rk[1];
    path_top[i] = 1;
    for(i = 1; i <= path_cnt; i++) {
        tree[i] = ++nodecnt;
        build(tree[i], 1, path_size[i] + 1);
    }
    for(i = 1; i < n; i++) work(i, w[i]);
}

int query(int a, int b) {
    int ans = -INF, x = bel[a], y = bel[b], k;
    while(x != y) {
        if(path_dep[x] > path_dep[y]) {
            k = ask(tree[x], rk[a], path_size[x] + 1);
            ans = max(ans, k);
            a = fa[path_top[x]];
            x = bel[a];
        } else {
            k = ask(tree[y], rk[b], path_size[y] + 1);
            ans = max(ans, k);
            b = fa[path_top[y]];
            y = bel[b];
        }
    }
    if(rk[a] == rk[b]) return ans;
    int ra = rk[a], rb = rk[b];
    if(ra > rb) k = ask(tree[x], rb, ra);
    else k = ask(tree[x], ra, rb);
    return max(ans, k);
}

int main() {
    scanf("%d", &T);
    while(T--) {
        init();
        scanf("%d", &n);
        for(int i = 1; i < n; i++) {
            scanf("%d %d %d", &a, &b, &c);
            add(a, b, c, i);
        }
        prepare();
        while(scanf("%s", cmd) && cmd[0] != 'D') {
            scanf("%d %d", &x, &y);
            if(cmd[0] == 'C') work(x, y);
            else if(cmd[0] == 'N') update(x, y);
            else printf("%d\n", query(x, y));
        }
    }
    return 0;
}