BZOJ 1036 树的统计（线段树+树链剖分）

Description

一棵树上有n个节点，编号分别为1到n，每个节点都有一个权值w。我们将以下面的形式来要求你对这棵树完成一些操作： I. CHANGE u t : 把结点u的权值改为t II. QMAX u v: 询问从点u到点v的路径上的节点的最大权值 III. QSUM u v: 询问从点u到点v的路径上的节点的权值和 注意：从点u到点v的路径上的节点包括u和v本身

Input

输入的第一行为一个整数n，表示节点的个数。接下来n – 1行，每行2个整数a和b，表示节点a和节点b之间有一条边相连。接下来n行，每行一个整数，第i行的整数wi表示节点i的权值。接下来1行，为一个整数q，表示操作的总数。接下来q行，每行一个操作，以“CHANGE u t”或者“QMAX u v”或者“QSUM u v”的形式给出。 对于100％的数据，保证1<=n<=30000，0<=q<=200000；中途操作中保证每个节点的权值w在-30000到30000之间。

Output

对于每个“QMAX”或者“QSUM”的操作，每行输出一个整数表示要求输出的结果。

Sample Input

4
1 2
2 3
4 1
4 2 1 3
12
QMAX 3 4
QMAX 3 3
QMAX 3 2
QMAX 2 3
QSUM 3 4
QSUM 2 1
CHANGE 1 5
QMAX 3 4
CHANGE 3 6
QMAX 3 4
QMAX 2 4
QSUM 3 4

Sample Output

4
1
2
2
10
6
5
6
5
16

 

思路：

树上路径问题，首先树链剖分，然后建线段树，线段树中元素存储区间和和区间最大值，那么三种操作就变成了线段树单点更新与区间查询操作（区间最大值和区间求和）.

 

代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
#define maxn 33333
#define INF 0x3f3f3f3f
struct Edge
{
    int to,next;
}E[2*maxn];
struct Tree
{
    int left,right,Max,Sum;
}T[4*maxn];
int n,q,val[maxn],head[maxn],cnt;
int idx;//时间戳,用于得到dfs序
int size[maxn];//size[i]表示以i节点为根节点的子树中节点个数
int fa[maxn];// fa[i]表示i节点的父亲节点
int son[maxn];//son[i]表示i节点的重儿子节点(如果没有重儿子则son[i]=i)
int dep[maxn];//dep[i]表示i节点在树中的深度
int top[maxn];//top[i]表示i节点所处重链中深度最低的节点
int id[maxn];//id[i]表示i节点的dfs序
int pos[maxn];//pos[i]表示dfs序为i的节点
void init()
{
    cnt=idx=0;
    memset(head,-1,sizeof(head));//默认1节点为根节点,初始化其父亲节点为0,深度为0 
    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,fa,dep,son
{
    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;//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,id,pos,l,r 
{
    top[u]=topu;
    id[u]=++idx;//得到u节点的dfs序 
    pos[idx]=u;//记录这个dfs序对应的节点 
    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 push_up(int t)
{
    T[t].Max=max(T[2*t].Max,T[2*t+1].Max);
    T[t].Sum=T[2*t].Sum+T[2*t+1].Sum;
}
void build(int l,int r,int t)
{
    T[t].left=l;
    T[t].right=r;
    T[t].Max=-INF;
    T[t].Sum=0;
    if(l==r)
    {
        T[t].Max=T[t].Sum=val[pos[l]];
        return ;
    }
    int mid=(l+r)>>1;
    build(l,mid,2*t);
    build(mid+1,r,2*t+1);
    push_up(t);
}
void update(int x,int v,int t)
{
    if(T[t].left==x&&T[t].right==x)
    {
        T[t].Max=T[t].Sum=v;
        return ;
    }
    if(x<=T[2*t].right) update(x,v,2*t);
    else update(x,v,2*t+1);
    push_up(t);
}
int query_sum(int l,int r,int t)
{
    if(T[t].left==l&&T[t].right==r) return T[t].Sum;
    if(r<=T[2*t].right) return query_sum(l,r,2*t);
    else if(l>=T[2*t+1].left) return query_sum(l,r,2*t+1);
    return query_sum(l,T[2*t].right,2*t)+query_sum(T[2*t+1].left,r,2*t+1);
}
int query_max(int l,int r,int t)
{
    if(T[t].left==l&&T[t].right==r) return T[t].Max;
    if(r<=T[2*t].right) return query_max(l,r,2*t);
    else if(l>=T[2*t+1].left) return query_max(l,r,2*t+1);
    return max(query_max(l,T[2*t].right,2*t),query_max(T[2*t+1].left,r,2*t+1));
}
int QSUM(int u,int v)
{
    int top1=top[u],top2=top[v],ans=0;
    while(top1!=top2)
    {
        if(dep[top1]<dep[top2])
        {
            swap(top1,top2);
            swap(u,v);
        }
        ans+=query_sum(id[top1],id[u],1);
        u=fa[top1];
        top1=top[u];
    }
    if(dep[u]>dep[v]) swap(u,v);
    ans+=query_sum(id[u],id[v],1);
    return ans;
}
int QMAX(int u,int 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_max(id[top1],id[u],1));
        u=fa[top1];
        top1=top[u];
    }
    if(dep[u]>dep[v]) swap(u,v);
    ans=max(ans,query_max(id[u],id[v],1));
    return ans;
}
int main()
{
    while(~scanf("%d",&n))
    {
        init();
        int u,v,c;char op[11];
        for(int i=1;i<n;i++)
        {
            scanf("%d%d",&u,&v);
            add(u,v),add(v,u);
        }
        for(int i=1;i<=n;i++) scanf("%d",&val[i]);
        dfs1(1);
        dfs2(1,1);
        build(1,n,1);
        scanf("%d",&q);
        while(q--)
        {
            scanf("%s",op);
            scanf("%d%d",&u,&v);
            if(op[0]=='C') update(id[u],v,1);
            else if(op[1]=='S') printf("%d\n",QSUM(u,v));
            else printf("%d\n",QMAX(u,v));
        }
    }
    return 0;
}