POJ 3237 Tree（树链剖分+线段树）

Description
一棵树有n个节点，n-1条边，每条边有一个权值，三种操作
CHANGE i v：将第i条边的权值改成v
NEGATE a b：将a到b路径上所有边的权值取反（x->-x)
QUERY a b：查询a到b路径上所有边权值的最大值
Input
第一行一个整数t表示用例组数，每组用例第一行一个整数n表示点数，之后n-1行每行三个整数a b c表示a点和b点之间有一条权值为c的边，之后数行每行一次操作，以DONE结束该组用例输入
Output
对于每次查询，输出查询结果
Sample Input
1
3
1 2 1
2 3 2
QUERY 1 2
CHANGE 1 3
QUERY 1 2
DONE
Sample Output
1
3
Solution
树上路径问题，首先树链剖分，然后建线段树，由于此题有取反操作，所以树中元素不仅要存区间最大值，还要存区间最小值，同时需要一个flag表示该区间是否被取反，之后就是线段树单点修改、区间更新以及区间查询问题了
Code

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
#define maxn 111111
#define INF 0x3f3f3f3f
struct Edge
{
    int to,next;
}E[2*maxn];
struct Tree
{
    int left,right,Min,Max,flag;//flag表示是否被取反 
}T[4*maxn];
int t,n,Q,e[maxn][3],head[maxn],cnt,idx,size[maxn],fa[maxn],son[maxn],dep[maxn],top[maxn],id[maxn];
void init()
{
    cnt=idx=0;
    memset(head,-1,sizeof(head));
    dep[1]=fa[1]=size[0]=0;
    memset(son,0,sizeof(son));
}
void add(int u,int v)
{
    E[cnt].to=v;
    E[cnt].next=head[u];
    head[u]=cnt++;
}
void dfs1(int u)
{
    size[u]=1;
    for(int i=head[u];~i;i=E[i].next)
    {
        int v=E[i].to;
        if(v!=fa[u])
        {
            fa[v]=u;
            dep[v]=dep[u]+1;
            dfs1(v);
            size[u]+=size[v];
            if(size[son[u]]<size[v]) son[u]=v;
        }
    }
}
void dfs2(int u,int topu)
{
    top[u]=topu;
    id[u]=++idx;
    if(son[u]) dfs2(son[u],top[u]);//先搜索重儿子 
    for(int i=head[u];~i;i=E[i].next)
    {
        int v=E[i].to;
        if(v!=fa[u]&&v!=son[u]) dfs2(v,v);
    }
}
void build(int l,int r,int t)
{
    T[t].left=l;
    T[t].right=r;
    T[t].Min=T[t].Max=T[t].flag=0;
    if(l==r) return ;
    int mid=(l+r)>>1;
    build(l,mid,2*t);
    build(mid+1,r,2*t+1); 
}
void push_up(int t)
{
    T[t].Min=min(T[2*t].Min,T[2*t+1].Min);
    T[t].Max=max(T[2*t].Max,T[2*t+1].Max);
}
void push_down(int t)
{
    if(T[t].left==T[t].right)return ;
    if(T[t].flag)
    {
        int Min,Max;
        Min=T[2*t].Min,Max=T[2*t].Max;
        T[2*t].Max=-Min,T[2*t].Min=-Max;
        Min=T[2*t+1].Min,Max=T[2*t+1].Max;
        T[2*t+1].Max=-Min,T[2*t+1].Min=-Max;
        T[2*t].flag^=1,T[2*t+1].flag^=1;
        T[t].flag=0;
    }
}
void update(int x,int v,int t)//将第x个节点的值变成v 
{
    if(T[t].left==x&&T[t].right==x)
    {
        T[t].Min=T[t].Max=v;
        T[t].flag=0;
        return ;
    }
    push_down(t);
    int mid=(T[t].left+T[t].right)>>1;
    if(x<=mid) update(x,v,2*t);
    else update(x,v,2*t+1);
    push_up(t);
}
int query(int l,int r,int t)//查询区间[l,r]中最大值 
{
    if(T[t].left==l&&T[t].right==r)
        return T[t].Max;
    push_down(t);
    int mid=(T[t].left+T[t].right)>>1;
    if(r<=mid) return query(l,r,2*t);
    else if(l>mid) return query(l,r,2*t+1);
    else return max(query(l,mid,2*t),query(mid+1,r,2*t+1));
    push_up(t);
}
void reverse(int l,int r,int t)//将区间[l,r]的值取反 
{
    if(T[t].left==l&&T[t].right==r)
    {
        int Min,Max;
        Min=T[t].Min,Max=T[t].Max;
        T[t].Max=-Min,T[t].Min=-Max;
        T[t].flag^=1;
        return ;
    }
    push_down(t);
    int mid=(T[t].left+T[t].right)>>1;
    if(r<=mid) reverse(l,r,2*t);
    else if(l>mid) reverse(l,r,2*t+1);
    else
    {
        reverse(l,mid,2*t);
        reverse(mid+1,r,2*t+1);
    }
    push_up(t);
}
int Get_max(int u,int v)//得到u->v路径上的最大值 
{
    int top1=top[u],top2=top[v],ans=-INF;
    while(top1!=top2)
    {
        if(dep[top1]<dep[top2])
        {
            swap(top1,top2);
            swap(u,v);
        }
        ans=max(ans,query(id[top1],id[u],1));
        u=fa[top1];
        top1=top[u];
    }
    if(u==v)return ans;
    if(dep[u]>dep[v])swap(u,v);
    return max(ans,query(id[son[u]],id[v],1));
}
void Negate(int u,int v)//将u->v路径上所有值取反 
{
    int top1=top[u],top2=top[v];
    while(top1!=top2)
    {
        if(dep[top1]<dep[top2])
        {
            swap(top1,top2);
            swap(u,v);
        }
        reverse(id[top1],id[u],1);
        u=fa[top1];
        top1=top[u];
    }
    if(u==v)return ;
    if(dep[u]>dep[v])swap(u,v);
    return reverse(id[son[u]],id[v],1);
}
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        init();//初始化 
        scanf("%d",&n);
        for(int i=1;i<n;i++)
        {
            scanf("%d%d%d",&e[i][0],&e[i][1],&e[i][2]);
            //建边 
            add(e[i][0],e[i][1]);
            add(e[i][1],e[i][0]);
        }
        dfs1(1);//得到dep,size,fa,son
        dfs2(1,1);//得到top,id 
        build(1,idx,1);//建树
        for(int i=1;i<n;i++)
        {
            if(dep[e[i][0]]>dep[e[i][1]])//定向,以达到以id[i]表示以i结尾的边 
                swap(e[i][0],e[i][1]);
            update(id[e[i][1]],e[i][2],1);
        }
        char op[11];
        while(~scanf("%s",op),op[0]!='D')
        {
            int u,v;
            scanf("%d%d",&u,&v);
            if(op[0]=='C')//单点更新 
                update(id[e[u][1]],v,1);
            else if(op[0]=='N')//区间取反 
                Negate(u,v);
            else//区间查询 
                printf("%d\n",Get_max(u,v));
        } 
    }
    return 0;
}