模板：树链剖分

最新推荐文章于 2024-03-24 17:40:24 发布

luyouqi233

最新推荐文章于 2024-03-24 17:40:24 发布

阅读量295

点赞数

分类专栏：模板

本文链接：https://blog.csdn.net/luyouqi233/article/details/78618542

版权

模板专栏收录该内容

10 篇文章 0 订阅

订阅专栏

前言：

“如果你会了树上dp，还会线段树……”

“没错！我都会啊！”

“……那你为什么写不出树链剖分？”

“？？？”

——by勇者和路由器的对话，今天二位仍然过得十分愉快

问题引入

BZOJ1036：[ZJOI2008]树的统计

题目描述

一棵树上有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本身

输入格式：

输入文件的第一行为一个整数n，表示节点的个数。

接下来n – 1行，每行2个整数a和b，表示节点a和节点b之间有一条边相连。

接下来一行n个整数，第i个整数wi表示节点i的权值。

接下来1行，为一个整数q，表示操作的总数。

接下来q行，每行一个操作，以“CHANGE u t”或者“QMAX u v”或者“QSUM u v”的形式给出。

输出格式：

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

输入样例：

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

输出样例：

4
1
2
2
10
6
5
6
5
16

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

思考：

我们发现题中要求的内容类似于线段树：单点修改，区间询问。

但是，这是一棵树啊！我们怎么才能在树上建一个只适用于一维的数据结构呢？

我们要抛弃线段树吗？

……

那么我们要试图把树拍扁成一维的吗？

……只能这样了。

其实拍扁成一维并不难想，考虑当树为一条链的时候吗，我们就直接上线段树即可。

那么类比一棵完整的树时，我们就把它分解成一条一条链然后拼在一起线段树维护即可。

关键问题在于要如何分解成链才能使得我们查询既快捷又方便呢？

这里当然就是树链剖分的活啦！

树链剖分：

概念：

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

我们称某条路径为重路径，当且仅当它全部由重边组成。

性质：

性质 1:轻边(U,V)，size(V)<=size(U)/2。

ž性质 2:从根到某一点的路径上，不超过O(logN)条轻边，不超过O(logN)条重路径。

对于性质1，我们肉眼观察法和反证法都能解决。

对于性质2就不是那么明显了，我们来证明一下：

由性质1可知，每经过一条轻边，子树的节点个数至少减少一半，所以至多经过 O (log n ) 条轻边。

而进入（或从……出去）一条重路径，一定需要经过一条轻边，所以至多经过 O (log n ) 条重路径。

有了以上两个性质之后，我们就可以发现这种分法的优越性了，我们仅仅只需要搜大概logn级别即可。

细节：

预处理：

我们具体需要求出7个值，分别为：

对于节点u：

父亲fa;

深度dep;

子树节点数size（又叫重量）;

重儿子son;

所在重路径的顶部节点top;

在序列的位置pos（下标）。

对于序列的一个下标：

对应树的位置idx。

前四个朴素dfs即可解决，后三个根据节点的重儿子再dfs即可解决。

注意：我们的目的是为了将树分解成重路径，所以第二次dfs建序列的时候要先加重儿子再管其他节点。

求值：

我们将u到v的路径分解成:

当u与v不在同一个重路径时：

u所在的部分重路径+top[u]到top[v]+v所在的部分重路径。

当u与v在同一个重路径时（显然不需要分解）

按照上面的方法递归并且不断求出这些段的值完后汇总即可。

那么我们就想先跳u为top[u]还是跳v为top[v]——方法就是，为了防止跳大了，跳得越少越好（比较top[u]和top[v]的dep即可）。

代码：

例题代码如下：

//luogu2590
//ZJOI2008树的统计
#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int N=30001;
const int INF=2147483647;
inline int read(){
    int X=0,w=0;char ch=0;
    while(ch<'0'||ch>'9'){w|=ch=='-';ch=getchar();}
    while(ch>='0'&&ch<='9')X=(X<<3)+(X<<1)+(ch^48),ch=getchar();
    return w?-X:X;
}
struct node{
    int to;
    int nxt;
}edge[2*N];
int head[N],cnt=0,n;
inline void add(int u,int v){
    cnt++;
    edge[cnt].to=v;
    edge[cnt].nxt=head[u];
    head[u]=cnt;
    return;
}
int fa[N],dep[N],size[N],son[N],top[N],pos[N],idx[N];
//依次为u的父亲,深度,重量,重儿子,重路径顶端,映射,反映射
int val[N],sum[N*4],maxn[N*4];
//依次为u的点权,区间和,区间最大值
void dfs1(int u){//处理fa,dep,size,son
    size[u]=1;
    for(int i=head[u];i;i=edge[i].nxt){
    int v=edge[i].to;
    if(v==fa[u])continue;
    fa[v]=u;dep[v]=dep[u]+1;
    dfs1(v);
    size[u]+=size[v];
    if(!son[u]||size[v]>size[son[u]])son[u]=v;//计算重儿子
    }
    return;
}
int tot;
void dfs2(int u,int anc){//处理top,pos,idx
    tot++;
    pos[u]=tot;
    idx[tot]=u;
    top[u]=anc;
    if(!son[u])return;//到叶子了
    dfs2(son[u],anc);//重路径上的点要在一段连续区间内所以先走重儿子
    for(int i=head[u];i;i=edge[i].nxt){
        int v=edge[i].to;
        if(v==fa[u]||v==son[u])continue;
        dfs2(v,v);//轻链top(anc)为自己
    }
    return;
}
void build(int a,int l,int r){//线段树建树
    if(l==r){
        sum[a]=maxn[a]=val[idx[l]];
        return;
    }
    int mid=(l+r)>>1;
    build(a*2,l,mid);
    build(a*2+1,mid+1,r);
    sum[a]=sum[a*2]+sum[a*2+1];
    maxn[a]=max(maxn[a*2],maxn[a*2+1]);
    return;
}
int querysum(int a,int l,int r,int l1,int r1){//线段树区间和
    if(r1<l||l1>r)return 0;
    if(l1<=l&&r<=r1)return sum[a];
    int mid=(l+r)>>1;
    return querysum(a*2,l,mid,l1,r1)+querysum(a*2+1,mid+1,r,l1,r1);
}
int querymax(int a,int l,int r,int l1,int r1){//线段树区间最大值
    if(r1<l||l1>r)return -INF;
    if(l1<=l&&r<=r1)return maxn[a];
    int mid=(l+r)>>1;
    return max(querymax(a*2,l,mid,l1,r1),querymax(a*2+1,mid+1,r,l1,r1));
}
void modify(int a,int l,int r,int p,int v){//线段树改值
    if(p<l||r<p)return;
    if(l==r){
        sum[a]=maxn[a]=v;
        return;
    }
    int mid=(l+r)>>1;
    modify(a*2,l,mid,p,v);
    modify(a*2+1,mid+1,r,p,v);
    sum[a]=sum[a*2]+sum[a*2+1];
    maxn[a]=max(maxn[a*2],maxn[a*2+1]);
    return;
}
int pathsum(int u,int v){//询问(u,v)这条路径的和
    if(top[u]!=top[v]){//不在同一条重链
        if(dep[top[u]]<dep[top[v]]){int t=u;u=v;v=t;}//一次爬少些，防止爬太大从而搜点搜多了
        return pathsum(fa[top[u]],v)+querysum(1,1,n,pos[top[u]],pos[u]);//爬掉一整个重路径
    }
    if(dep[u]>dep[v]){int t=u;u=v;v=t;}
    return querysum(1,1,n,pos[u],pos[v]);//一条重路径上一段
    //此时u是深度较小的那个点,也就是原路径的LCA
}
int pathmax(int u,int v){//询问(u,v)这条路径的最大值,代码含义基本同上
    if(top[u]!=top[v]){
        if(dep[top[u]]<dep[top[v]]){int t=u;u=v;v=t;}
        return max(pathmax(fa[top[u]],v),querymax(1,1,n,pos[top[u]],pos[u]));
    }
    if(dep[u]>dep[v]){int t=u;u=v;v=t;}
    return querymax(1,1,n,pos[u],pos[v]);
}
void init(){//初始化
    dep[1]=fa[1]=1;
    dfs1(1);
    top[1]=idx[1]=pos[1]=1;
    tot=0;
    dfs2(1,1);
    return;
}
int main(){
    n=read();
    for(int i=2;i<=n;i++){
        int u=read();
        int v=read();
        add(u,v);
        add(v,u);
    }
    for(int i=1;i<=n;i++)val[i]=read();
    init();
    build(1,1,n);
    int q=read();
    while(q--){
        char op[6];
        scanf("%s",op);
        int u=read();
        int v=read();
        if(op[0]=='C')modify(1,1,n,pos[u],v);
        else if(op[1]=='S')printf("%d\n",pathsum(u,v));
        else printf("%d\n",pathmax(u,v));
    }
    return 0;
}