JZOJ-senior-2256. 【ZJOI2008】树的统计

2256. 【ZJOI2008】树的统计 (Standard IO)

Time Limits: 2000 ms Memory Limits: 512000 KB Detailed Limits

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

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

Data Constraint

Hint

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

Solution

算法：树链剖分模板

理解：树链剖分就是将树分割成多条链，然后利用数据结构（线段树、树状数组等）来维护这些链。

首先就是一些必须知道的概念：

重结点：子树结点数目最多的结点；
轻节点：父亲节点中除了重结点以外的结点；
重边：父亲结点和重结点连成的边；
轻边：父亲节点和轻节点连成的边；
重链：由多条重边连接而成的路径；
轻链：由多条轻边连接而成的路径；

比如上面这幅图中，用黑线连接的结点都是重结点，其余均是轻结点，2-11、1-14、3-7就是重链，其他就是轻链，用红点标记的就是该结点所在链的起点，也就是我们下面提到的top结点，还有每条边的值其实是进行dfs时的执行序号。

算法中定义了以下的数组用来存储上边提到的概念：

siz[u]：保存以u为根的子树节点个数
top[u]：保存当前节点所在链的顶端节点
son[u]：保存重儿子
dep[u]：保存结点u的深度值
faz[u]：保存结点u的父亲节点
tid[u]：保存树中每个节点剖分以后的新编号，即DFS的执行顺序
rnk[u]：保存当前节点在树中的位置，即DFS序为u的结点编号

除此之外，还包括两种性质：

如果(u, v)是一条轻边，那么size(v) < size(u)/2；
从根结点到任意结点的路所经过的轻重链的个数必定都小与O(logn)；

Code

#include<algorithm>
#include<cstdio>
#define N 30010
#define INF 2147483647
using namespace std;
int i,n,m,x,y,t,cnt,w[N];
int son[N],dep[N],faz[N],size[N];
int top[N],tid[N],rnk[N],last[N];
char s[7];
struct node
{
    int to,next;
}a[2*N];
struct data
{
    int l,r,max,sum;
}tree[4*N];
void add(int x,int y)
{
    a[++t].to=y;
    a[t].next=last[x];
    last[x]=t;
}
void dfs1(int x,int f,int d)//更新son,dep,faz,size数组
{
    dep[x]=d,faz[x]=f;
    for(int w=last[x];w;w=a[w].next)
        if(a[w].to!=f)
        {
            dfs1(a[w].to,x,d+1);
            size[x]+=size[a[w].to];
            if(son[x]<0 || size[a[w].to]>size[son[x]])
                son[x]=a[w].to;
        }
}
void dfs2(int x,int tp)//更新top,tid,rnk数组
{
    cnt++,top[x]=tp,tid[x]=cnt,rnk[cnt]=x;
    if(son[x]<0) return;
    dfs2(son[x],tp);
    for(int w=last[x];w;w=a[w].next)
        if(a[w].to!=son[x] && a[w].to!=faz[x])
            dfs2(a[w].to,a[w].to);
}
void update(int k)
{
    int lk=k<<1,rk=lk+1;
    tree[k].sum=tree[lk].sum+tree[rk].sum;
    tree[k].max=max(tree[lk].max,tree[rk].max);
}
void make(int x,int l,int r)
{
    tree[x].l=l,tree[x].r=r;
    if(l==r)
    {
        tree[x].max=w[rnk[l]];
        tree[x].sum=w[rnk[l]];
        return;
    }
    int mid=(l+r)>>1;
    make(x+x,l,mid);
    make(x+x+1,mid+1,r);
    update(x);
}
void change(int x,int l,int r,int p,int v)
{
    if(l==r)
    {
        tree[x].sum=v;
        tree[x].max=v;
        return;
    } 
    int mid=(l+r)>>1;
    if(p<=mid) change(x+x,l,mid,p,v);
        else change(x+x+1,mid+1,r,p,v);
    update(x);
}
int dfs_max(int x,int u,int v)
{
    if(tree[x].l>=u && tree[x].r<=v) return tree[x].max;
    int mid=(tree[x].l+tree[x].r)>>1,mx=-INF;
    if(u<=mid) mx=max(mx,dfs_max(x+x,u,v));
    if(v>mid) mx=max(mx,dfs_max(x+x+1,u,v));
    return mx;
}
int dfs_sum(int x,int u,int v)
{
    int l=x<<1,r=l+1;
    if(tree[x].l>=u && tree[x].r<=v) return tree[x].sum;
    int mid=(tree[x].l+tree[x].r)>>1,sum=0;
    if(u<=mid) sum+=dfs_sum(x+x,u,v);
    if(v>mid) sum+=dfs_sum(x+x+1,u,v);
    return sum;
}
int find_max(int u,int v)
{
    int f1=top[u],f2=top[v],ans=-INF;
    while(f1!=f2)
    {
        if(dep[f1]<dep[f2]) swap(f1,f2),swap(u,v);
        ans=max(ans,dfs_max(1,tid[f1],tid[u]));
        u=faz[f1],f1=top[u];
    }
    if(dep[u]>dep[v]) swap(u,v);
    ans=max(ans,dfs_max(1,tid[u],tid[v]));
    return ans;
}
int find_sum(int u,int v)
{
    int f1=top[u],f2=top[v],ans=0;
    while(f1!=f2)
    {
        if(dep[f1]<dep[f2]) swap(f1,f2),swap(u,v);
        ans+=dfs_sum(1,tid[f1],tid[u]);
        u=faz[f1],f1=top[u];
    }
    if(dep[u]>dep[v]) swap(u,v);
    ans+=dfs_sum(1,tid[u],tid[v]);
    return ans;
}
int main()
{
    freopen("tree.in","r",stdin);
    freopen("tree.out","w",stdout);
    scanf("%d",&n);
    for(i=1;i<n;i++) scanf("%d%d",&x,&y),add(x,y),add(y,x);
    for(i=1;i<=n;i++) scanf("%d",&w[i]),size[i]=1,son[i]=-1;
    dfs1(1,0,1),dfs2(1,1),make(1,1,n);
    scanf("%d",&m);
    for(i=1;i<=m;i++)
    {
        scanf("%s%d%d",&s,&x,&y);
        if(s[0]=='C') change(1,1,n,tid[x],y),w[x]=y;
        else printf("%d\n",s[1]=='M'?find_max(x,y):find_sum(x,y));
    }
}

树链剖分详解
树链剖分原理和实现