POJ 3237 Tree 树链剖分

题目大意：

就是现在给出一棵树, 有边权值, 有3种操作

1.询问从点a到b的路径上边权的最大值

2.将a到b路径上的所有边的边权值取反

3 将第i条边的权值更改为w

大致思路：

就是很明显的树链剖分的题, 第三道树链剖分的练习题

树链剖分之后用线段树维护的时候记录当前区间的最小值和最大值然后利用懒惰标记即可

代码如下：

Result  :  Accepted     Memory  :  1360 KB     Time  :  630 ms

/*
 * Author: Gatevin
 * Created Time:  2015/9/8 10:03:38
 * File Name: Sakura_Chiyo.cpp
 */
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;

#define maxn 10010

int top[maxn];
int grandson[maxn];
int dep[maxn];
int siz[maxn];
int belong[maxn];
int father[maxn];
int Q[maxn];
int cnt;
int hson[maxn];

int n;
bool vis[maxn];
int id[maxn];
int antiID[maxn];

struct Edge
{
    int u, v, w, nex;//u->v
    Edge(int _u, int _v, int _w, int _nex)
    {
        u = _u, v = _v, w = _w, nex = _nex;
    }
    Edge(){}
};

Edge edge[maxn << 1];
int tot;
int head[maxn];
int w[maxn];

void add_Edge(int x, int y, int w)
{
    edge[++tot] = Edge(x, y, w, head[x]);
    head[x] = tot;
}

void split()
{
    cnt = 0;
    int l = 0, r = 1;
    dep[Q[r] = 1] = 1;
    father[r] = -1;
    w[r] = 0;
    while(l < r)
    {
        int x = Q[++l];
        if(head[x] == -1) continue;
        for(int j = head[x]; j + 1; j = edge[j].nex)
        {
            int y = edge[j].v;
            if(y == father[x]) continue;
            w[y] = edge[j].w;
            dep[Q[++r] = y] = dep[x] + 1;
            father[y] = x;
        }
    }
    for(int i = n; i; i--)
    {
        int x = Q[i], p = -1;
        siz[x] = 1;
        if(head[x] == -1) continue;
        for(int j = head[x]; j + 1; j = edge[j].nex)
        {
            int y = edge[j].v;
            if(y == father[x]) continue;
            siz[x] += siz[y];
            if(p == -1 || (p > 0 && siz[y] > siz[p]))
                p = y;
        }
        if(p == -1)
        {
            hson[x] = -1;
            grandson[++cnt] = x;
            belong[top[cnt] = x] = cnt;
        }
        else
        {
            hson[x] = p;
            belong[x] = belong[p];
            top[belong[x]] = x;
        }
    }
    int idx = 0;
    memset(vis, 0, sizeof(vis));
    for(int i = n; i; i--)
    {
        int x = Q[i];
        if(vis[x]) continue;
        vis[x] = 1;
        id[x] = ++idx;
        antiID[idx] = x;
        while(father[x] != -1 && belong[father[x]] == belong[x] && !vis[father[x]])
        {
            x = father[x];
            id[x] = ++idx;
            antiID[idx] = x;
            vis[x] = 1;
        }
    }
    return;
}

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
int ma[maxn << 2];//max value
int mi[maxn << 2];//min value
int flag[maxn << 2];

void pushUp(int rt)
{
    ma[rt] = max(ma[rt << 1], ma[rt << 1 | 1]);
    mi[rt] = min(mi[rt << 1], mi[rt << 1 | 1]);
    return;
}

void pushDown(int rt)
{
    if(flag[rt] == -1)
    {
        flag[rt << 1] *= flag[rt];
        flag[rt << 1 | 1] *= flag[rt];
        swap(ma[rt << 1], mi[rt << 1]);
        ma[rt << 1] *= -1;
        mi[rt << 1] *= -1;
        swap(ma[rt << 1 | 1], mi[rt << 1 | 1]);
        ma[rt << 1 | 1] *= -1;
        mi[rt << 1 | 1] *= -1;
        flag[rt] = 1;
    }
    return;
}

void build(int l, int r, int rt)
{
    flag[rt] = 1;
    if(l == r)
    {
        ma[rt] = mi[rt] = w[antiID[l]];
        return;
    }
    int mid = (l + r) >> 1;
    build(lson);
    build(rson);
    pushUp(rt);
    return;
}

void update(int l, int r, int rt, int pos, int value)//单点修改
{
    if(l == r)
    {
        mi[rt] = ma[rt] = value;
        return;
    }
    int mid = (l + r) >> 1;
    pushDown(rt);
    if(pos <= mid) update(lson, pos, value);
    else update(rson, pos, value);
    pushUp(rt);
    return;
}

void negative(int l, int r, int rt, int L, int R)
{
    if(l >= L && r <= R)
    {
        flag[rt] *= -1;
        ma[rt] *= -1;
        mi[rt] *= -1;
        swap(ma[rt], mi[rt]);
        return;
    }
    int mid = (l + r) >> 1;
    pushDown(rt);
    if(mid >= L) negative(lson, L, R);
    if(mid + 1 <= R) negative(rson, L, R);
    pushUp(rt);
    return;  
}

int query(int l, int r, int rt, int L, int R)
{
    if(l >= L && r <= R)
        return ma[rt];
    int mid = (l + r) >> 1;
    pushDown(rt);
    int ret = -1e9;
    if(mid >= L) ret = max(ret, query(lson, L, R));
    if(mid + 1 <= R) ret = max(ret, query(rson, L, R));
    return ret;
}

int answer(int l, int r)
{
   int ans = -1e9;
   while(top[belong[l]] != top[belong[r]])
   {
       if(dep[top[belong[l]]] < dep[top[belong[r]]]) swap(l, r);
       ans = max(ans, query(1, n, 1, id[l], id[top[belong[l]]]));
       l = father[top[belong[l]]];
   }
   if(l == r) return ans;
   if(dep[l] < dep[r]) swap(l, r);
   ans = max(ans, query(1, n, 1, id[l], id[hson[r]]));
   return ans;
}

void change(int l, int r)
{
    while(top[belong[l]] != top[belong[r]])
    {
        if(dep[top[belong[l]]] < dep[top[belong[r]]]) swap(l, r);
        negative(1, n, 1, id[l], id[top[belong[l]]]);
        l = father[top[belong[l]]];
    }
    if(l == r) return;
    if(dep[l] < dep[r]) swap(l, r);
    negative(1, n, 1, id[l], id[hson[r]]);
    return;
}
    
int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        memset(head, -1, sizeof(head));
        tot = 0;
        scanf("%d", &n);
        int u, v, w;
        for(int i = 1; i < n; i++)
        {
            scanf("%d %d %d", &u, &v, &w);
            add_Edge(u, v, w);
            add_Edge(v, u, w);
        }
        split();
        build(1, n, 1);
        char op[10];
        while(scanf("%s", op))
        {
            if(op[0] == 'D') break;
            if(op[0] == 'Q')
            {
                scanf("%d %d", &u, &v);
                printf("%d\n", answer(u, v));
            }
            else if(op[0] == 'N')
            {
                scanf("%d %d", &u, &v);
                change(u, v);
            }
            else if(op[0] == 'C')
            {
                scanf("%d %d", &u, &w);
                int x = edge[u << 1].u;
                int y = edge[u << 1].v;
                if(father[x] == y)
                    update(1, n, 1, id[x], w);
                else update(1, n, 1, id[y], w);
            }
        }
    }
    return 0;
}