POJ - 3237 Tree(树剖 ＋ 区间修改)

题目大意：给你一棵树，然后给你三种操作
C i v:将第i条边的权值变成v
N a b:将a到b的所有的边的权值取相反数
Q a b:将a到b的边的最大值输出来

解题思路：用线段树维护两个值，一个是最大值，一个是最小值
当区间取反的时候，交换最大值跟最小值，然后两个取相反数就可以了
还有一点要注意的，区间修改的lazy标志，并不是传递下去的，而是分奇偶的，因为区间被取相反数偶数次的话，就相当于不变了

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 10010;
const int M = 10010 << 2;
const int INF = 0x3f3f3f3f;

struct Edge{
    int u, v, dis, next;
    Edge() {}
    Edge(int u, int v, int dis, int next): u(u), v(v), dis(dis), next(next){}
}E[N * 2];

int head[N], size[N], son[N], f[N], top[N], dep[N], id[N];
int n, tot, idx;
int val[M], mark[M], Min[M], Max[M];

void PushUp(int u) {
    Max[u] = max(Max[u << 1], Max[u << 1 | 1]);
    Min[u] = min(Min[u << 1], Min[u << 1 | 1]);
}

void build(int u, int l, int r) {
    mark[u] = 0;
    if (l == r) {
        Min[u] = Max[u] = val[l];
        return ;
    }
    int mid = (l + r) >> 1;
    build(u << 1, l, mid);
    build(u << 1 | 1, mid + 1, r);
    PushUp(u);
}

void dfs1(int u, int fa, int depth) {
    size[u] = 1; f[u] = fa; dep[u] = depth; son[u] = 0;
    for (int i = head[u]; ~i; i = E[i].next) {
        int v = E[i].v;
        if (v == fa) continue;
        dfs1(v, u, depth + 1);
        size[u] += size[v];
        if (size[v] > size[son[u]]) son[u] = v;
    }
}

void dfs2(int u, int tp) {
    top[u] = tp;
    id[u] = ++idx;
    if (son[u]) dfs2(son[u], tp);
    for (int i = head[u]; ~i; i = E[i].next) {
        int v = E[i].v;
        if (v == f[u] || v == son[u]) continue;
        dfs2(v, v); 
    }
}

void PushDown(int u, int l, int r) {
    mark[u << 1] += mark[u];
    mark[u << 1 | 1] += mark[u];
    Max[u << 1] = -Max[u << 1];
    Min[u << 1] = -Min[u << 1];
    Min[u << 1 | 1] = -Min[u << 1 | 1];
    Max[u << 1 | 1] = -Max[u << 1 | 1];
    swap(Min[u << 1], Max[u << 1]);
    swap(Min[u << 1 | 1], Max[u << 1 | 1]);
    mark[u] = 0;
}

int Query(int u, int l, int r, int L, int R) {
    if (L <= l && r <= R) return Max[u];
    if (mark[u] % 2) PushDown(u, l, r);

    int mid = (l + r) >> 1;
    if (R <= mid) return Query(u << 1, l, mid, L, R);
    else if (L > mid) return Query(u << 1 | 1, mid + 1, r, L, R);
    else return max(Query(u << 1, l, mid, L, mid), Query(u << 1 | 1, mid + 1, r, mid + 1, R));
}

void Modify(int u, int l, int r, int L, int R, int c, int flag) {
    if (l == L && r == R) {
        if (flag) Min[u] = Max[u] = c;
        else {
            mark[u] += 1;
            swap(Min[u], Max[u]);
            Min[u] = -Min[u];
            Max[u] = -Max[u];
        }
        return ;
    }
    int mid = (l + r) >> 1;
    if (mark[u] % 2) PushDown(u, l, r);
    if (R <= mid) Modify(u << 1, l, mid, L, R, c, flag);
    else if (L > mid) Modify(u << 1 | 1, mid + 1, r, L, R, c, flag);
    else {
        Modify(u << 1, l, mid, L, mid, c, flag);
        Modify(u << 1 | 1, mid + 1, r, mid + 1, R, c, flag);
    }
    PushUp(u);
}

void gao(int u, int v, int flag) {
    int tp1 = top[u], tp2 = top[v];
    int ans = -INF;
    while (tp1 != tp2) {
        if (dep[tp1] < dep[tp2]) {
            swap(tp1, tp2);
            swap(u, v);
        }
        if (flag)
            ans = max(ans, Query(1, 1, idx, id[tp1], id[u]));
        else 
            Modify(1, 1, idx, id[tp1], id[u], -1, flag);
        u = f[tp1];
        tp1 = top[u];
    }
    if (u != v) { 
        if (dep[u] > dep[v]) swap(u ,v);
        if (flag)
            ans = max(ans, Query(1, 1, idx, id[son[u]], id[v]));
        else Modify(1, 1, idx, id[son[u]], id[v], -1, flag);
    }
    if (flag) printf("%d\n", ans);
}

void solve() {

    char op[30];
    int a, b;
    while (scanf("%s", op) && op[0] != 'D') {
        scanf("%d%d", &a, &b);
        if (op[0] == 'Q') gao(a, b, 1);
        else if (op[0] == 'C'){
            int l = id[E[2 * (a - 1)].u];
            Modify(1, 1, idx, l, l, b, 1);
        }
        else gao(a, b, 0);
    }
}

void AddEdge(int u, int v, int dis) {
    E[tot] = Edge(u, v, dis, head[u]);
    head[u] = tot++;
    E[tot] = Edge(v, u, dis, head[v]);
    head[v] = tot++;
}

void init() {
    scanf("%d", &n);
    memset(head, -1, sizeof(head));
    tot = 0;

    int u, v, dis;
    for (int i = 1; i < n; i++) {
        scanf("%d%d%d", &u, &v, &dis);
        AddEdge(u, v, dis);
    }

    idx = 0;
    dfs1(1, 0, 1);
    dfs2(1, 1);

    for (int i = 0; i < tot; i += 2) {
        if (dep[E[i].u] < dep[E[i].v]) swap(E[i].u, E[i].v);
        val[id[E[i].u]] = E[i].dis;
    }
    build(1, 1, idx);
}

int main() {
    int test;
    scanf("%d", &test);
    while (test--) {
        init();
        solve();
    }
    return 0;
}