JZOJsenior2256.【ZJOI2008】树的统计

problem

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”的形式给出。

Output

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

Sample Input
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

Data Constraint

Hint

【数据说明】
　　对于100％的数据，保证1<=n<=30000，0<=q<=200000；中途操作中保证每个节点的权值w在-30000到30000之间。
　

---

analysis

树剖例题
先用轻重链剖分把树剖好，用线段树维护每一条重链
然后用树剖求$LCA$的过程中，用线段树查询记录答案（路径最大值、和）
时间复杂度$O(n+qlog_2^2n)$

由于写过很详细的树剖blog了，这里不加赘述

---

code

#include<cstdio>
#define MAXN 30001
#define INF 1000000007

using namespace std;

int last[3*MAXN],next[3*MAXN],tov[3*MAXN];
int to_num[MAXN];
int n,m,tot,total;
char st[10];

struct information
{
    int depth,father,size,heavy_son,top,to_tree,value;
}a[MAXN];

struct point
{
    int mx,ans;
}tree[MAXN*4];

int max(int x,int y)
{
    return x>y?x:y;
}

void insert(int x,int y)
{
    next[++tot]=last[x];
    last[x]=tot;
    tov[tot]=y;
}

void dfs1(int x,int father)
{
    int mx=-1;
    a[x].size=1;
    for (int i=last[x];i;i=next[i])
    {
        int j=tov[i];
        if (j!=father)
        {
            a[j].depth=a[x].depth+1;
            a[j].father=x;
            dfs1(j,x);
            a[x].size+=a[j].size;
            if (a[j].size>mx)
            {
                mx=a[j].size;
                a[x].heavy_son=j;
            }
        }
    }
}

void dfs2(int x,int father,int k)
{
    if (x==0)return;
    a[x].top=k;
    a[x].to_tree=++total;
    to_num[total]=x;
    dfs2(a[x].heavy_son,x,k);
    for (int i=last[x];i;i=next[i])
    {
        int j=tov[i];
        if (j!=father && j!=a[x].heavy_son && j!=0)
        {
            dfs2(j,x,j);
        }
    }
}

void maketree(int t,int l,int r)
{
    if (l==r)
    {
        tree[t].ans=tree[t].mx=a[to_num[l]].value;
        return;
    }
    int mid=(l+r)/2;
    maketree(t*2,l,mid);
    maketree(t*2+1,mid+1,r);
    tree[t].ans=tree[t*2].ans+tree[t*2+1].ans;
    tree[t].mx=max(tree[t*2].mx,tree[t*2+1].mx);
}

void change(int t,int l,int r,int x,int y)
{
    if (l==r)
    {
        tree[t].ans=tree[t].mx=y;
        return;
    }
    int mid=(l+r)/2;
    if (x<=mid)
    {
        change(t*2,l,mid,x,y);
    }
    else
    {
        change(t*2+1,mid+1,r,x,y);
    }
    tree[t].mx=max(tree[t*2].mx,tree[t*2+1].mx);
    tree[t].ans=tree[t*2].ans+tree[t*2+1].ans;
}

int tree_query_max(int t,int l,int r,int x,int y)
{
    if (l==x && r==y)
    {
        return tree[t].mx;
    }
    int mid=(l+r)/2;
    if (y<=mid)
    {
        return tree_query_max(t*2,l,mid,x,y);
    }
    else if (x>mid)
    {
        return tree_query_max(t*2+1,mid+1,r,x,y);
    }
    else
    {
        return max(tree_query_max(t*2,l,mid,x,mid),tree_query_max(t*2+1,mid+1,r,mid+1,y));
    }
}

int tree_query_sum(int t,int l,int r,int x,int y)
{
    if (l==x && r==y)
    {
        return tree[t].ans;
    }
    int mid=(l+r)/2;
    if (y<=mid)
    {
        return tree_query_sum(t*2,l,mid,x,y);
    }
    else if (x>mid)
    {
        return tree_query_sum(t*2+1,mid+1,r,x,y);
    }
    else
    {
        return tree_query_sum(t*2,l,mid,x,mid)+tree_query_sum(t*2+1,mid+1,r,mid+1,y);
    }
}

int query_max(int x,int y)
{
    int temp=-INF;
    while (a[x].top!=a[y].top)
    {
        if (a[a[x].top].depth>a[a[y].top].depth)
        {
            temp=max(temp,tree_query_max(1,1,n,a[a[x].top].to_tree,a[x].to_tree));
            x=a[a[x].top].father;
        }
        else 
        {
            temp=max(temp,tree_query_max(1,1,n,a[a[y].top].to_tree,a[y].to_tree));
            y=a[a[y].top].father;
        }
    }
    if (a[x].depth<a[y].depth)
    {
        temp=max(temp,tree_query_max(1,1,n,a[x].to_tree,a[y].to_tree));
    }
    else
    {
        temp=max(temp,tree_query_max(1,1,n,a[y].to_tree,a[x].to_tree));
    }
    return temp;
}

int query_sum(int x,int y)
{
    int temp=0;
    while (a[x].top!=a[y].top)
    {
        if (a[a[x].top].depth>a[a[y].top].depth)
        {
            temp+=tree_query_sum(1,1,n,a[a[x].top].to_tree,a[x].to_tree);
            x=a[a[x].top].father;
        }
        else 
        {
            temp+=tree_query_sum(1,1,n,a[a[y].top].to_tree,a[y].to_tree);
            y=a[a[y].top].father;
        }
    }
    if (a[x].depth<a[y].depth)
    {
        temp+=tree_query_sum(1,1,n,a[x].to_tree,a[y].to_tree);
    }
    else
    {
        temp+=tree_query_sum(1,1,n,a[y].to_tree,a[x].to_tree);
    }
    return temp;
}

int main()
{
    //freopen("readin.txt","r",stdin);

    scanf("%d",&n);
    for (int i=1;i<n;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        insert(x,y);
        insert(y,x);
    }
    for (int i=1;i<=n;i++)
    {
        scanf("%d",&a[i].value);
    }
    a[1].depth=1,a[1].father=0;
    dfs1(1,0),dfs2(1,0,1);
    maketree(1,1,n);
    scanf("%d",&m);
    for (int i=1;i<=m;i++)
    {
        int x,y;
        scanf("%s %d %d",&st,&x,&y);
        if (st[1]=='M')
        {
            printf("%d\n",query_max(x,y));
        }
        else if (st[1]=='S')
        {
            printf("%d\n",query_sum(x,y));
        }
        else
        {   
            change(1,1,n,a[x].to_tree,y);
        }
    }    
    return 0;
}