poj3237 Tree

Description

You are given a tree with N nodes. The tree’s nodes are numbered 1 through N and its edges are numbered 1 through N − 1. Each edge is associated with a weight. Then you are to execute a series of instructions on the tree. The instructions can be one of the following forms:

CHANGE i v	Change the weight of the ith edge to v
NEGATE a b	Negate the weight of every edge on the path from a to b
QUERY a b	Find the maximum weight of edges on the path from a to b

Input

The input contains multiple test cases. The first line of input contains an integer t (t ≤ 20), the number of test cases. Then follow the test cases.

Each test case is preceded by an empty line. The first nonempty line of its contains N (N ≤ 10,000). The next N − 1 lines each contains three integers a, b and c, describing an edge connecting nodes a and b with weight c. The edges are numbered in the order they appear in the input. Below them are the instructions, each sticking to the specification above. A lines with the word “DONE” ends the test case.

Output

For each “QUERY” instruction, output the result on a separate line.

Sample Input

1

3
1 2 1
2 3 2
QUERY 1 2
CHANGE 1 3
QUERY 1 2
DONE

Sample Output

1
3

好惨啊……有一个加1的没写结果最裸的树链剖分调了一整天
线段树维护最大值和最小值，对于一条链上权值取反的操作只要mx=-mn,mn=-mx即可

#include<cstdio>
#include<iostream>
#include<cstring>
#define LL long long
#define inf 1000000000
#define N 10010
using namespace std;
int bin[15]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384};
inline LL read()
{
    LL x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct segtree{int l,r,mx,mn,tag;}tree[4*N];
struct edge{int to,next,v;}e[2*N];
int T,n,cnt,tt,mx;
char ch[10];
int head[N];
int fa[N][15],son[N],depth[N],v[N];
bool mrk[N];
int place[N],pplace[N],belong[N];
int query[N];
inline void revswap(int &a,int &b){int t=a;a=-b;b=-t;}
inline void ins(int u,int v,int w)
{
	e[++cnt].to=v;
	e[cnt].v=w;
	e[cnt].next=head[u];
	head[u]=cnt;
}
inline void insert(int u,int v,int w)
{
	ins(u,v,w);
	ins(v,u,w);
}
inline void dfs(int x,int dep)
{
	if (mrk[x])return;mrk[x]=1;
	depth[x]=dep;son[x]=1;
	for (int i=1;i<15;i++)
		if (bin[i]<=depth[x])
		  	fa[x][i]=fa[fa[x][i-1]][i-1];
		else break;
	for (int i=head[x];i;i=e[i].next)
		if (!mrk[e[i].to])
		{
			fa[e[i].to][0]=x;
			dfs(e[i].to,dep+1);
			v[e[i].to]=e[i].v;
			son[x]+=son[e[i].to];
			query[(i+1)>>1]=e[i].to;
		}
}
inline void dfs2(int x,int chain)
{
	place[x]=++tt;pplace[tt]=x;
	belong[x]=chain;
	int res=0,mx=-inf;
	for (int i=head[x];i;i=e[i].next)
		if (fa[x][0]!=e[i].to)
		{
			if (son[e[i].to]>mx)
			{
				mx=son[e[i].to];
				res=e[i].to;
			}
		}
	if (!res)return;
	dfs2(res,chain);
	for (int i=head[x];i;i=e[i].next)
		if (fa[x][0]!=e[i].to&&res!=e[i].to)
			dfs2(e[i].to,e[i].to);
}
inline int LCA(int a,int b)
{
	if (depth[a]<depth[b])swap(a,b);
	int res=depth[a]-depth[b];
	for (int i=0;i<15;i++)
		if (res & bin[i]) a=fa[a][i];
	for (int i=14;i>=0;i--)
		if (fa[a][i]!=fa[b][i])
		{
			a=fa[a][i];
			b=fa[b][i];
		}
	if (a==b)return a;
	return fa[a][0];
}
inline void pushdown(int k)
{
	tree[k].tag=0;
	tree[k<<1].tag^=1;tree[k<<1|1].tag^=1;
	revswap(tree[k<<1].mx,tree[k<<1].mn);
	revswap(tree[k<<1|1].mx,tree[k<<1|1].mn);
}
inline void update(int k)
{
	tree[k].mx=max(tree[k<<1].mx,tree[k<<1|1].mx);
	tree[k].mn=min(tree[k<<1].mn,tree[k<<1|1].mn);
}
inline void buildtree(int now,int l,int r)
{
	tree[now].l=l;tree[now].r=r;
	if (l==r)
	{
		tree[now].mx=tree[now].mn=v[pplace[l]];
		return;
	}
	int mid=(l+r)>>1;
	buildtree(now<<1,l,mid);
	buildtree(now<<1|1,mid+1,r);
	update(now);
}
inline void change_in_tree(int now,int x,int y)
{
	int l=tree[now].l,r=tree[now].r;
	if (l!=r&&tree[now].tag)pushdown(now);
	if (l==r)
	{
		tree[now].mx=tree[now].mn=y;
		return;
	}
	int mid=(l+r)>>1;
	if (x<=mid)change_in_tree(now<<1,x,y);
	else change_in_tree(now<<1|1,x,y);
	update(now);
}
inline void negate_in_tree(int now,int x,int y)
{
	int l=tree[now].l,r=tree[now].r;
	if (l!=r&&tree[now].tag)pushdown(now);
	if (l==x&&r==y)
	{
		revswap(tree[now].mx,tree[now].mn);
		tree[now].tag=1;
		return;
	}
	int mid=(l+r)>>1;
	if (y<=mid)negate_in_tree(now<<1,x,y);
	else if (x>mid)negate_in_tree(now<<1|1,x,y);
	else
	{
		negate_in_tree(now<<1,x,mid);
		negate_in_tree(now<<1|1,mid+1,y);
	}
	update(now);
}
inline void ask_in_tree(int now,int x,int y)
{
	int l=tree[now].l,r=tree[now].r;
	if (l!=r&&tree[now].tag)pushdown(now);
	if (l==x&&r==y)
	{
		mx=max(mx,tree[now].mx);
		return;
	}
	int mid=(l+r)>>1;
	if (y<=mid)ask_in_tree(now<<1,x,y);
	else if (x>mid)ask_in_tree(now<<1|1,x,y);
	else
	{
		ask_in_tree(now<<1,x,mid);
		ask_in_tree(now<<1|1,mid+1,y);
	}
}
inline void reverse(int from,int to)
{
	if (from==to)return;
	int l,r;
	while (belong[from]!=belong[to])
	{
		l=place[belong[from]];r=place[from];
		negate_in_tree(1,l,r);
		from=fa[belong[from]][0];
	}
	if (place[to]+1<=place[from])
	negate_in_tree(1,place[to]+1,place[from]);
}
inline int ask(int from,int to)
{
	int l,r;mx=-inf;
	if (from==to)return mx;
	while (belong[from]!=belong[to])
	{
		l=place[belong[from]];r=place[from];
		ask_in_tree(1,l,r);
		from=fa[belong[from]][0];
	}
	if (place[to]+1<=place[from])
	ask_in_tree(1,place[to]+1,place[from]);
	return mx;
}
inline void work()
{
	memset(tree,0,sizeof(tree));
	memset(head,0,sizeof(head));
	memset(e,0,sizeof(e));
	memset(mrk,0,sizeof(mrk));
	memset(query,0,sizeof(query));
	memset(place,0,sizeof(place));
	memset(pplace,0,sizeof(pplace));
	memset(belong,0,sizeof(belong));
	memset(fa,0,sizeof(fa));
	memset(son,0,sizeof(son));
	memset(depth,0,sizeof(depth));
	memset(v,0,sizeof(v));
	tt=cnt=0;
	n=read();
	for (int i=1;i<n;i++)
	{
		int x=read(),y=read(),z=read();
		insert(x,y,z);
	}
	dfs(1,0);
	dfs2(1,1);
	buildtree(1,1,n);
	while (scanf("%s",ch+1)&&ch[1]!='D')
	{
		int a=read(),b=read();
		if (ch[1]=='C')change_in_tree(1,place[query[a]],b);
		if (ch[1]=='N')
		{
			int c=LCA(a,b);
			reverse(a,c);
			reverse(b,c);
		}
		if (ch[1]=='Q')
		{
			int c=LCA(a,b);
			printf("%d\n",max( ask(a,c),ask(b,c) ));
		}
	}
}
int main()
{
	T=read();
	while (T--)work();
}