POJ 3237 Tree 树链剖分（路径剖分

题意：有n-1条路，形成一棵树，每条路有一个权值，有三种操作

1.CHANGE i v 把第i条路权值改为v

2.NEGATE a b把路径a~b的权值全部取反

3.QUERY a b 查询路径a~b的权值的最大值

思路：

有区别有点剖分的是，我们用deep比较大的点来保存这条边，在进行链合并的时候注意在LCA的地方不能去LCA的值，因为LCA的值是LCA-deep更小的边，并不是这条路径上的边

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<math.h>
#include<queue>
#include<stack>
#include<string>
#include<vector>
#include<map>
#include<set>
using namespace std;
#define lowbit(x) (x&(-x))
typedef long long LL;
#define maxn 10005
const int inf=1000000000;
int S[20];
int max(int a,int b)
{
if(a>b) return a;
return b;
}
int min(int a,int b)
{
if(a>b) return b;
return a;
}
struct node
{
int next,to,v;
}e[maxn*2];
int h[maxn],tot;
void add_edge(int a,int b,int c)
{
e[++tot].next=h[a];
e[tot].to=b;
e[tot].v=c;
h[a]=tot;
}
//graph**************************
int ft[maxn][14];
int fa[maxn],deep[maxn],son[maxn],siz[maxn];
void dfs1(int u,int pre,int dep)
{
fa[u]=pre;
deep[u]=dep;
siz[u]=1;
for(int i=1;i<14;++i)
{
if(dep<S[i]) break;
ft[u][i]=ft[ft[u][i-1]][i-1];
}
for(int i=h[u];~i;i=e[i].next)
{
int v=e[i].to;
if(v!=pre)
{
ft[v][0]=u;
dfs1(v,u,dep+1);
siz[u]+=siz[v];
if(son[u]==-1||siz[son[u]]<siz[v])
son[u]=v;
}
}
}
int top[maxn],tid[maxn],Rank[maxn];
int tim;
void dfs2(int u,int tp)
{
top[u]=tp;
tid[u]=++tim;
Rank[tim]=u;
if(son[u]==-1) return ;
dfs2(son[u],tp);
for(int i=h[u];~i;i=e[i].next)
{
int v=e[i].to;
if(v!=fa[u]&&v!=son[u])
dfs2(v,v);
}
}
int lca(int x,int y)
{
if(deep[x]<deep[y]) swap(x,y);
int t=deep[x]-deep[y];
for(int i=0;i<14;++i)
if(t&S[i]) x=ft[x][i];
for(int i=13;i>=0;--i)
if(ft[x][i]!=ft[y][i])
{
x=ft[x][i];
y=ft[y][i];
}
if(x==y) return x;
return ft[x][0];
}
//树剖***************************
struct Segment
{
int Max,Min,lazy;
}tree[maxn*4];
void Push_up(int rt)
{
tree[rt].Max=max(tree[rt*2].Max,tree[rt*2+1].Max);
tree[rt].Min=min(tree[rt*2].Min,tree[rt*2+1].Min);
}
void fun(int rt)
{
tree[rt].Min*=-1;
tree[rt].Max*=-1;
swap(tree[rt].Min,tree[rt].Max);
tree[rt].lazy^=1;
}
void Push_down(int rt)
{
if(tree[rt].lazy)
{
fun(rt*2);fun(rt*2+1);
tree[rt].lazy=0;
}
}
void build(int l,int r,int rt)
{
tree[rt].lazy=0;
tree[rt].Max=-inf;
tree[rt].Min=inf;
if(l==r) return ;
int mid=(l+r)/2;
build(l,mid,rt*2);
build(mid+1,r,rt*2+1);
}
void Insert(int pos,int l,int r,int rt,int c)
{
if(l==r)
{
tree[rt].Max=tree[rt].Min=c;
return ;
}
Push_down(rt);
int mid=(l+r)/2;
if(pos<=mid) Insert(pos,l,mid,rt*2,c);
else Insert(pos,mid+1,r,rt*2+1,c);
Push_up(rt);
}
void query(int left,int right,int l,int r,int rt,int &Max)
{
if(left<=l&&r<=right)
{
Max=max(tree[rt].Max,Max);
return ;
}
Push_down(rt);
int mid=(l+r)/2;
if(left<=mid)
query(left,right,l,mid,rt*2,Max);
if(right>mid)
query(left,right,mid+1,r,rt*2+1,Max);
Push_up(rt);
}
void update(int left,int right,int l,int r,int rt)
{
if(left<=l&&r<=right)
{
fun(rt);
return ;
}
Push_down(rt);
int mid=(l+r)/2;
if(left<=mid)
update(left,right,l,mid,rt*2);
if(right>mid)
update(left,right,mid+1,r,rt*2+1);
Push_up(rt);
}
//Segment************************
int n;
void Change(int x,int t)
{
while(top[x]!=top[t])
{
update(tid[top[x]],tid[x],1,n,1);
x=fa[top[x]];
}
update(tid[t],tid[x],1,n,1);
}
int Solve(int x,int t)
{
int Max=-inf;
while(top[x]!=top[t])
{
query(tid[top[x]],tid[x],1,n,1,Max);
x=fa[top[x]];
}
if(x==t) return Max;
query(tid[son[t]],tid[x],1,n,1,Max);
return Max;
}
void init()
{
tot=tim=0;
memset(h,-1,sizeof(h));
memset(son,-1,sizeof(son));
memset(fa,0,sizeof(fa));
}
struct AAA
{
int u,v,c;
}A[maxn];
int main()
{
int T;
S[0]=1;
for(int i=1;i<15;++i) S[i]=S[i-1]*2;
scanf("%d",&T);
while(T--)
{
init();
scanf("%d",&n);
for(int i=1;i<n;++i)
{
int u,v,c;
scanf("%d%d%d",&u,&v,&c);
add_edge(u,v,c);
add_edge(v,u,c);
A[i].u=u;A[i].v=v;
A[i].c=c;
}
dfs1(1,1,0);
dfs2(1,1);
build(1,n,1);
for(int i=1;i<n;++i)
{
int x;
if(deep[A[i].u]<deep[A[i].v]) swap(A[i].u,A[i].v);
x=A[i].u;
Insert(tid[x],1,n,1,A[i].c);
}
while(1)
{
char str[10];
scanf("%s",str);
int x,y;
if(str[0]=='D') break;
scanf("%d%d",&x,&y);
if(str[0]=='Q')
{
int t=lca(x,y);
int Max=Solve(x,t);
Max=max(Solve(y,t),Max);
printf("%d\n",Max);
}
else if(str[0]=='N')
{
int t=lca(x,y);
Change(x,t);
Change(y,t);
}
else
{
int t=A[x].u;
Insert(tid[t],1,n,1,y);
}
}
}
return 0;
}