【码极客精讲】树链剖分

树链剖分，计算机术语，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链。

树路径信息维护算法。

将一棵树划分成若干条链，用数据结构去维护每条链，复杂度为O(logN)。

其实本质是一些数据结构/算法在树上的推广。

常见的路径剖分的方法是轻重树链剖分（启发式剖分）

将树中的边分为：轻边和重边 定义size(X)为以X为根的子树的节点个数。 令V为U的儿子节点中size值最大的节点，那么边(U,V)被称为重边，树中重边之外的边被称为轻边。

性质：轻边(U,V)，size(V)＜=size(U)/2。 从根到某一点的路径上，不超过O(logN)条轻边，不超过O(logN)条重路径。

预处理

第一遍dfs求出树每个结点的深度deep[x]，其为根的子树大小size[x]

以及祖先的信息fa[x][i]表示x往上距离为2^i的祖先

第二遍dfs

根节点为起点，向下拓展构建重链

选择最大的一个子树的根继承当前重链

其余节点，都以该节点为起点向下重新拉一条重链

给每个结点分配一个位置编号，每条重链就相当于一段区间，用数据结构去维护。

把所有的重链首尾相接，放到同一个数据结构上，然后维护这一个整体即可

修改操作

1、单独修改一个点的权值

根据其编号直接在数据结构中修改就行了。

2、修改点u和点v的路径上的权值

（1）若u和v在同一条重链上

直接用数据结构修改pos[u]至pos[v]间的值。

（2）若u和v不在同一条重链上

一边进行修改，一边将u和v往同一条重链上靠，然后就变成了情况（1）。

CHANGE (x, y ,d)
while top[x]≠top[y]
do if dep[top[x]]＜dep[top[y]]
then SWAP(x,y), SWAP (gx,gy)
CHANGE-IT(tid[top[x]],tid[x],d)
fa[x]→x
if dep[x]＞dep[y]
then SWAP (x,y)
CHANGE-IT(tid[x],tid[y],d)
//CHANGE-IT(l,r,d)为数据结构的修改操作：将区间[l,r]上的所有权值改为d

查询操作

查询操作的分析过程同修改操作

伪代码

QUERY (x, y)
while top[x]≠top[y]
do if dep[top[x]]＜dep[top[y]]
then SWAP (x,y), SWAP (gx,gy)
QUERY-IT(tid[top[x]],tid[x])
fa[x]→x
if dep[x]＞dep[y]
then SWAP (x,y)
QUERY-IT(tid[x],tid[y])
//QUERY-IT(l,r)为数据结构的查询操作，

题目不同，选用不同的数据结构来维护值，通常有线段树和splay

再看一题题目。

ZJOI2008树的统计

I. CHANGE u t : 把结点u的权值改为t

II. QMAX u v: 询问从点u到点v的路径上的节点的最大权值

III. QSUM u v: 询问从点u到点v的路径上的节点的权值和

注意：从点u到点v的路径上的节点包括u和v本身

 

//by hzwer
#include<iostream>
#include<cstdio>
#include<cstring>
#define inf 0x7fffffff
#define N 30005 
#define M 60005
using namespace std;
int n,q,cnt,sz;
int fa[N][15],v[N],deep[N],size[N],head[N];
int pos[N],belong[N];
bool vis[N];
struct data{int to,next;}e[M];
struct seg{int l,r,mx,sum;}t[100005];
void insert(int u,int v)
{
    e[++cnt].to=v;e[cnt].next=head[u];head[u]=cnt;
    e[++cnt].to=u;e[cnt].next=head[v];head[v]=cnt;
}
void ini()
{
    scanf("%d",&n);
    for(int i=1;i<n;i++)
    {
 int x,y;
 scanf("%d%d",&x,&y);
 insert(x,y);
 }
    for(int i=1;i<=n;i++)scanf("%d",&v[i]);
}
void dfs1(int x)
{
    size[x]=1;vis[x]=1;
    for(int i=1;i<=14;i++)
    {
        if(deep[x]<(1<<i))break;
        fa[x][i]=fa[fa[x][i-1]][i-1];//倍增处理祖先信息
    }
    for(int i=head[x];i;i=e[i].next)
    {
        if(vis[e[i].to])continue;
        deep[e[i].to]=deep[x]+1;
        fa[e[i].to][0]=x;
        dfs1(e[i].to);
        size[x]+=size[e[i].to];
    }
}
void dfs2(int x,int chain)
{
    int k=0;sz++;
    pos[x]=sz;//分配x结点在线段树中的编号
 belong[x]=chain;
    for(int i=head[x];i;i=e[i].next)
        if(deep[e[i].to]>deep[x]&&size[e[i].to]>size[k])
            k=e[i].to;//选择子树最大的儿子继承重链
    if(k==0)return;
    dfs2(k,chain);
    for(int i=head[x];i;i=e[i].next)
        if(deep[e[i].to]>deep[x]&&k!=e[i].to)
            dfs2(e[i].to,e[i].to);//其余儿子新开重链
}
int lca(int x,int y)//求lca
{
    if(deep[x]<deep[y])swap(x,y);
    int t=deep[x]-deep[y];
    for(int i=0;i<=14;i++)
        if(t&(1<<i))x=fa[x][i];
    for(int i=14;i>=0;i--)
        if(fa[x][i]!=fa[y][i]) 
        {x=fa[x][i];y=fa[y][i];}
    if(x==y)return x;
    else return fa[x][0];
}
void build(int k,int l,int r)//建线段树
{
    t[k].l=l;t[k].r=r;
    if(l==r)return;
    int mid=(l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
}
void change(int k,int x,int y)//线段树单点修改
{
    int l=t[k].l,r=t[k].r,mid=(l+r)>>1;
    if(l==r){t[k].sum=t[k].mx=y;return;}
    if(x<=mid)change(k<<1,x,y);
    else change(k<<1|1,x,y);
    t[k].sum=t[k<<1].sum+t[k<<1|1].sum;
    t[k].mx=max(t[k<<1].mx,t[k<<1|1].mx);
}
int querysum(int k,int x,int y)//线段树区间求和
{
    int l=t[k].l,r=t[k].r,mid=(l+r)>>1;
    if(l==x&&y==r)return t[k].sum;
    if(y<=mid)return querysum(k<<1,x,y);
    else if(x>mid)return querysum(k<<1|1,x,y);
    else {return querysum(k<<1,x,mid)+querysum(k<<1|1,mid+1,y);}
}
int querymx(int k,int x,int y)//线段树区间求最大值
{
    int l=t[k].l,r=t[k].r,mid=(l+r)>>1;
    if(l==x&&y==r)return t[k].mx;
    if(y<=mid)return querymx(k<<1,x,y);
    else if(x>mid)return querymx(k<<1|1,x,y);
    else {return max(querymx(k<<1,x,mid),querymx(k<<1|1,mid+1,y));}
}
int solvesum(int x,int f)
{
    int sum=0;
    while(belong[x]!=belong[f])//不在一条重链上就将x跳到链首，走一条轻边，如此反复
    {
        sum+=querysum(1,pos[belong[x]],pos[x]);
        x=fa[belong[x]][0];
    }
    sum+=querysum(1,pos[f],pos[x]);
    return sum;
}
int solvemx(int x,int f)
{
    int mx=-inf;
    while(belong[x]!=belong[f])
    {
        mx=max(mx,querymx(1,pos[belong[x]],pos[x]));
        x=fa[belong[x]][0];
    }
    mx=max(mx,querymx(1,pos[f],pos[x]));
    return mx;
}
void solve()
{
    build(1,1,n);
    for(int i=1;i<=n;i++)
        change(1,pos[i],v[i]);
    scanf("%d",&q);char ch[6];
    for(int i=1;i<=q;i++) 
    {
        int x,y;scanf("%s%d%d",ch,&x,&y);
        if(ch[0]=='C'){v[x]=y;change(1,pos[x],y);}
        else
        {
            int t=lca(x,y);
            if(ch[1]=='M')
                printf("%d\n",max(solvemx(x,t),solvemx(y,t)));
            else
                printf("%d\n",solvesum(x,t)+solvesum(y,t)-v[t]);
        }
    }
}
int main()
{
    ini();
    dfs1(1);
    dfs2(1,1);
    solve();
    return 0;
}