ural题目1553.cavesandtunnels（linkcuttree改动点权，求两点之间最大）

4
1 2
2 3
2 4
6
I 1 1
G 1 1
G 3 4
I 2 3
G 1 1
G 3 4 

1
0
1
3

Tags: data structures  (

)

瞬秒~~

题目大意：一棵树，開始每一个点权的权值为0，后边q次操作。I a b,a点点权加b。G a b查询从a到b要走的最大的权值

ac代码

#include<stdio.h>         
#include<string.h>     
#include<queue>   
#include<iostream>   
#define INF 0x7fffffff   
#define max(a,b) (a>b?a:b)   
using namespace std;  
int vis[100050];      
struct LCT      
{      
    int bef[100050],pre[100050],next[100050][2],key[100050],val[100050];      
    void init()      
    {      
        memset(pre,0,sizeof(pre));      
        memset(next,0,sizeof(next));
		memset(key,0,sizeof(key));
        val[0]=-INF; 
    }    
    void pushup(int x)    
    {     
        val[x]=max(key[x],max(val[next[x][1]],val[next[x][0]]));   
    }    
    void rotate(int x,int kind)      
    {      
        int y,z;      
        y=pre[x];      
        z=pre[y];      
        next[y][!kind]=next[x][kind];      
        pre[next[x][kind]]=y;      
        next[z][next[z][1]==y]=x;      
        pre[x]=z;      
        next[x][kind]=y;      
        pre[y]=x;      
        pushup(y);    
    }      
    void splay(int x)      
    {      
        int rt;      
        for(rt=x;pre[rt];rt=pre[rt]);      
        if(x!=rt)      
        {      
            bef[x]=bef[rt];      
            bef[rt]=0;      
            while(pre[x])      
            {      
                if(next[pre[x]][0]==x)      
                {      
                    rotate(x,1);      
                }      
                else    
                    rotate(x,0);      
            }     
            pushup(x);    
        }      
    }      
    void access(int x)      
    {      
        int fa;      
        for(fa=0;x;x=bef[x])      
        {      
            splay(x);      
            pre[next[x][1]]=0;      
            bef[next[x][1]]=x;      
            next[x][1]=fa;      
            pre[fa]=x;      
            bef[fa]=0;      
            fa=x;    
            pushup(x);    
        }      
    }      
    void change(int x,int y)  
    {  
        key[x]+=y;  
        splay(x);  
    }  
    int query(int x,int y)  
    {  
        access(y);  
        for(y=0;x;x=bef[x])  
        {  
            splay(x);  
            if(!bef[x])  
            {  
                  return max(key[x],max(val[next[x][1]],val[y]));  
            }  
            pre[next[x][1]]=0;  
            bef[next[x][1]]=x;  
            next[x][1]=y;  
            pre[y]=x;  
            bef[y]=0;  
            y=x;  
            pushup(x);  
        }  
        return 0;  
    }  
}lct;  
struct s  
{  
    int u,v,next;  
}edge[200020<<1];  
int head[200020],cnt;  
void add(int u,int v)  
{  
    edge[cnt].u=u;  
    edge[cnt].v=v;  
    edge[cnt].next=head[u];  
    head[u]=cnt++;  
}  
void bfs(int u)     
{                   
    queue<int>q;          
    memset(vis,0,sizeof(vis));          
    vis[u]=1;          
    q.push(u);          
    while(!q.empty())          
    {              
        u=q.front();              
        q.pop();              
        for(int i=head[u];i!=-1;i=edge[i].next)              
        {                  
            int v=edge[i].v;                  
            if(!vis[v])                  
            {                      
                lct.bef[v]=u;                                    
                vis[v]=1;                      
                q.push(v);                  
            }              
        }          
    }      
} 
int main()
{
	int n;
	while(scanf("%d",&n)!=EOF)
	{
		int i=1;
		memset(head,-1,sizeof(head));
		cnt=0;
		for(i=1;i<n;i++)
		{
			int u,v;
			scanf("%d%d",&u,&v);
			add(u,v);
			add(v,u);
		}
		int q;
		scanf("%d",&q);
		lct.init();
		bfs(1);
		while(q--)
		{
			char str[2];
			int u,v;
			scanf("%s%d%d",str,&u,&v);
			if(str[0]==‘I‘)
				lct.change(u,v);
			else
				printf("%d
",lct.query(u,v));
		}
	}
}