BZOJ1036: [ZJOI2008]树的统计Count - 树链剖分 -

1036: [ZJOI2008]树的统计Count

Description

　　一棵树上有n个节点，编号分别为1到n，每个节点都有一个权值w。我们将以下面的形式来要求你对这棵树完成
一些操作： I. CHANGE u t : 把结点u的权值改为t II. QMAX u v: 询问从点u到点v的路径上的节点的最大权值 I
II. 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

HINT

Source

Solution

　　剖一下，线段树维护一下。

　　模板题……

Code

#include<map>
#include<set>
#include<cmath>
#include<ctime>
#include<deque>
#include<queue>
#include<stack>
#include<cstdio>
#include<vector>
#include<climits>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
const int Maxn=1000000+1;
struct tree_chain_partition
{
    struct segment_tree
    {
        struct node
        {
            int sum,max;
            int l,r,lc,rc;
        }tr[Maxn<<1];
        int root;
        void Push_Up(int x)
        {
            int lc=tr[x].lc;
            int rc=tr[x].rc;
            tr[x].sum=tr[lc].sum+tr[rc].sum;
            tr[x].max=max(tr[lc].max,tr[rc].max);
        }
        void Build(int x,int l,int r)
        {
            tr[x].l=l;
            tr[x].r=r;
            if(l==r)
            {
                tr[x].lc=0;
                tr[x].rc=0;
                return;
            }
            tr[x].lc=x<<1;
            tr[x].rc=(x<<1)+1;
            int mid=(l+r)>>1;
            Build(tr[x].lc,l,mid);
            Build(tr[x].rc,mid+1,r);
        }
        void Modify(int x,int pos,int val)
        {
            if(tr[x].l==tr[x].r)
            {
                tr[x].sum=val;
                tr[x].max=val;
                return;
            }
            int mid=(tr[x].l+tr[x].r)>>1;
            if(pos<=mid)Modify(tr[x].lc,pos,val);
            else Modify(tr[x].rc,pos,val);
            Push_Up(x);
        }
        int Query_Sum(int x,int l,int r)
        {
            if(tr[x].l==l&&tr[x].r==r)return tr[x].sum;
            int mid=(tr[x].l+tr[x].r)>>1;
            if(r<=mid)return Query_Sum(tr[x].lc,l,r);
            else if(mid<l)return Query_Sum(tr[x].rc,l,r);
            else return Query_Sum(tr[x].lc,l,mid)+Query_Sum(tr[x].rc,mid+1,r);
        }
        int Query_Max(int x,int l,int r)
        {
            if(tr[x].l==l&&tr[x].r==r)return tr[x].max;
            int mid=(tr[x].l+tr[x].r)>>1;
            if(r<=mid)return Query_Max(tr[x].lc,l,r);
            else if(mid<l)return Query_Max(tr[x].rc,l,r);
            else return max(Query_Max(tr[x].lc,l,mid),Query_Max(tr[x].rc,mid+1,r));
        }
    }seg;
    struct node
    {
        int id,fa,dep,son,top,val,size;
    }tr[Maxn];
    int root;
    struct edge
    {
        int y,next;
    }road[Maxn<<1];
    int len;
    int first[Maxn];
    void Insert(int x,int y)
    {
        len++;
        road[len].y=y;
        road[len].next=first[x];
        first[x]=len;
    }
    void Build(int x,int fa)
    {
        tr[x].fa=fa;
        tr[x].son=0;
        tr[x].size=1;
        tr[x].dep=tr[fa].dep+1;
        for(int k=first[x];k!=0;k=road[k].next)
        {
            int y=road[k].y;
            if(y!=fa)Build(y,x);
        }
        tr[fa].size+=tr[x].size;
        if(tr[tr[fa].son].size<tr[x].size)tr[fa].son=x;
    }
    void Modify(int x,int val)
    {
        tr[x].val=val;
        seg.Modify(seg.root,tr[x].id,val);
    }
    int id;
    void DFS(int x,int top)
    {
        tr[x].id=++id;
        tr[x].top=top;
        if(tr[x].son!=0)DFS(tr[x].son,top);
        for(int k=first[x];k!=0;k=road[k].next)
        {
            int y=road[k].y;
            if(y!=tr[x].fa&&y!=tr[x].son)DFS(y,y);
        }
    }
    void Partitioning(int n)
    {
        seg.root=1;
        seg.Build(seg.root,1,n);
        id=0;
        DFS(root,root);
    }
    int Query_Sum(int x,int y)
    {        
        int res=0;
        while(tr[x].top!=tr[y].top)
        {
            if(tr[tr[x].top].dep<tr[tr[y].top].dep)swap(x,y);
            res+=seg.Query_Sum(seg.root,tr[tr[x].top].id,tr[x].id);
            x=tr[tr[x].top].fa;
        }
        if(tr[x].dep<tr[y].dep)swap(x,y);
        res+=seg.Query_Sum(seg.root,tr[y].id,tr[x].id);
        return res;
    }
    int Query_Max(int x,int y)
    {        
        int res=INT_MIN;
        while(tr[x].top!=tr[y].top)
        {
            if(tr[tr[x].top].dep<tr[tr[y].top].dep)swap(x,y);
            res=max(res,seg.Query_Max(seg.root,tr[tr[x].top].id,tr[x].id));
            x=tr[tr[x].top].fa;
        }
        if(tr[x].dep<tr[y].dep)swap(x,y);
        res=max(res,seg.Query_Max(seg.root,tr[y].id,tr[x].id));
        return res;
    }
}tra;
int main()
{
    // freopen("a.in","r",stdin);
    // freopen("a.out","w",stdout);
    int n;
    scanf("%d",&n);
    for(int i=1;i<n;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        tra.Insert(x,y);
        tra.Insert(y,x);
    }
    tra.root=1;
    tra.Build(tra.root,0);
    tra.Partitioning(n);
    for(int i=1;i<=n;i++)
    {
        int x;
        scanf("%d",&x);
        tra.Modify(i,x);
    }
    int m;
    scanf("%d",&m);
    for(int i=1;i<=m;i++)
    {
        char st[6];
        scanf("%s",st);
        int x,y;
        scanf("%d%d",&x,&y);
        if(st[1]=='S')printf("%d\n",tra.Query_Sum(x,y));
        else if(st[1]=='M')printf("%d\n",tra.Query_Max(x,y));
        else tra.Modify(x,y);
    }
    return 0;
}