树链剖分（轻重链）入门

最新推荐文章于 2024-07-19 13:59:11 发布
最新推荐文章于 2024-07-19 13:59:11 发布
阅读量3.6k 收藏 77
点赞数 18
分类专栏： 算法刷题 文章标签： 算法 线段树 深搜 DFS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35866893/article/details/123957047
版权

写在前面

仅想学树剖LCA的同学其实不必要了解线段树
前置知识：树形结构，链式前向星(熟练)，线段树(熟练)，DFS序(熟练)，LCA(了解定义)

树链剖分（树剖）：将树分解为一条条不相交的，从祖先到孙子的链。

第零部分：建树与基本概念

建树：给定n个节点用链式前向星建树，这里不做过多赘述，值得一提的是要深入理解建树加边的过程。

基本概念：
1.重儿子：假设x有n个儿子节点，其中以3儿子节点的为根子树大小最大，3就是x的重儿子
2.轻儿子：除重儿子外的所有儿子均为轻儿子
以下图为例
1的重儿子为3，轻儿子为2
3的重儿子为6，其余的为轻儿子
3.轻边：x与轻儿子相连的边
4.重边：x与重儿子相连的边
5.轻链：均由轻儿子构成的一条链
6.重链：均由重儿子构成的一条链
请添加图片描述

第一部分：预处理节点信息

我们需要的信息如下
dep[X]：x节点的深度
fa[X]：x节点的父亲节点
son[X]：x节点的重儿子
siz[X]：x节点为根的子树大小

top[X]：x节点所在链的顶点
稍微有些晕？不要紧，接着往下看如何用两个DFS实现
首先第一个DFS我们直接获取dep[X]，fa[X]，son[X]，siz[X]

void DFS1(int now,int fath)//传入当前节点和当前节点父亲节点编号{
    fa[now]=fath;
    siz[now]=1;son[now]=0;
    dep[now]=dep[fath]+1;
    for(int i=head[now];i;i=edge[i].nex){
        if(edge[i].to==fath)
            continue;
        DFS1(edge[i].to,now);
        siz[now]+=siz[edge[i].to];
        if(siz[son[now]]<siz[edge[i].to]) //当now节点的重儿子不在是最大的，时候更新了
        {
            son[now]=edge[i].to;
        }
    }
}

接下来获取top[X]
我们处理的方式：优先对重儿子处理，重儿子处理结束后再处理轻儿子（新开链）

void DFS2(int now,int topx)//topx，先重儿子再轻儿子
{
    top[now]=topx;
    if(son[now]){
        DFS2(son[now],topx);
    }
    else
        return ;
    for(int i=head[now];i;i=edge[i].nex)
    {
        if(edge[i].to!=fa[now]&&edge[i].to!=son[now])
        {
            DFS2(edge[i].to,edge[i].to);
        }
    }
}

看到这里，我们已经可以求解LCA问题了

实例：树剖LCA

OJ：P3379 【模板】最近公共祖先（LCA）
我们来看看预处理后树剖LCA的代码

int LCA(int x,int y){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]])
            swap(x,y);
        x=fa[top[x]];
    }
    return dep[x]<dep[y]?x:y;
}

当我们把每个节点对应top记录好了之后，我们要获取两个节点的LCA完全可以通过让当前节点“跳跃”到当前节点所在链的顶端的父节点来实现（还记得我们剖分的不相交的链吗）,每次选取当前两个节点中top的深度较大的来跳转。
AC代码 非压行

#include <bits/stdc++.h>
using namespace std;
struct node
{
    int nex,to;
};
const int N=5e5+10;
node edge[N<<1];
int dep[N],head[N],tot,fa[N],top[N],son[N],siz[N];
void add(int from,int to)
{
    edge[++tot].nex=head[from];
    edge[tot].to=to;
    head[from]=tot;
}
void DFS1(int now,int fath)
{
    fa[now]=fath;
    siz[now]=1;son[now]=0;
    dep[now]=dep[fath]+1;
    for(int i=head[now];i;i=edge[i].nex){
        if(edge[i].to==fath)
            continue;
        DFS1(edge[i].to,now);
        siz[now]+=siz[edge[i].to];
        if(siz[son[now]]<siz[edge[i].to])
            son[now]=edge[i].to;
    }
}
void DFS2(int now,int topx)//topx，先重儿子再轻儿子
{
    top[now]=topx;
    if(son[now])
    {
        DFS2(son[now],topx);
    }
    else
        return ;
    for(int i=head[now];i;i=edge[i].nex)
    {
        if(edge[i].to!=fa[now]&&edge[i].to!=son[now])
        {
            DFS2(edge[i].to,edge[i].to);
        }
    }
}
int LCA(int x,int y)
{
    while(top[x]!=top[y])
    {
        if(dep[top[x]]<dep[top[y]])
        {
            swap(x,y);
        }
        x=fa[top[x]];
    }
    return dep[x]<dep[y]?x:y;
}
int main()
{
    int n,l,r,m,s;
    cin>>n>>m>>s;
    for(int i=1;i<=n-1;i++)
    {
        cin>>l>>r;
        add(l,r);
        add(r,l);
    }
    DFS1(s,0);
    DFS2(s,s);
    for(int i=1;i<=m;i++)
    {
        int x,y;
        cin>>x>>y;
        cout<<LCA(x,y)<<endl;
    }
	return 0;
}

OK，学到这里如果要是只想学树剖LCA和普通的树上操作读者可以去找树上差分的文章，如果想要继续学习树剖的线段树维护可以继续阅读~

第二部分：树上操作

欢迎来到树链剖分最后的挑战：线段树优化树上操作
我们先分析一下第一部分，看看为什么要用线段树去优化（记着线段树的擅长区域：区间问题）。

第一部分分析：
首先，我们用DFS1获取了dep[X]，fa[X]，son[X]，siz[X]
接着我们用DFS2获取了top[x]。我们来看看DFS2遍历数的过程：先重儿子，再轻儿子
先重儿子，再轻儿子，总是先遍历重儿子的话，一条重链上的遍历顺序是连续的！既然是连续的，那么一条重链就是一整个区间！

上图！

我们观察1 3 6 10这条链已然在新编节点中是1 2 3 4（区间）

观察以新编号为2的节点作为根的子树，里面是2 3 4 5 6（区间）

所以：一条重链和一个子树都恰好是一个区间

我们再来看一般性的情况：源节点从9到8,可以分为：9到2，2到1，8到3，3到1，四条链来进行操作

（圆圈内对应的原本节点的编号，蓝色数字对应的是DFS2遍历的顺序）
在这里插入图片描述
根据刚才的分析
1.我们需要在第一部分的DFS2加料，按照DFS2的DFS序来统计出新的节点编号和对应的新节点的权值
2.我们需要根据新的节点编号和新的权值来构造一颗线段树
3.借助我们存储的新节点编号把题目中给咱们的旧节点翻译成新节点来调用线段树。

我们来给DFS2加点东西

void DFS2(int now,int topx)//topx，先重儿子再轻儿子！！！！
{
    top[now]=topx;
    nid[now]=++cnt;//nid is new_id
    nw[cnt]=w[now];//nw is new_weight
    if(son[now])
        DFS2(son[now],topx);
    else
        return ;
    for(int i=head[now];i;i=edge[i].nex)
        if(edge[i].to!=fa[now]&&edge[i].to!=son[now])
            DFS2(edge[i].to,edge[i].to);
}

okk！我们记录好了新编节点和新编节点对应的重量了！
接下来，我们生成线段树！

void up(int p)
{
    tree[p]=tree[ls]+tree[rs];
}
void down(int l,int r,int p)
{
    tag[ls]+=tag[p];
    tag[rs]+=tag[p];
    tree[ls]+=(mid-l+1)*tag[p];
    tree[ls]%=mod;
    tree[rs]+=(r-mid)*tag[p];
    tree[rs]%=mod;
    tag[p]=0;
}
void bulid(int l,int r,int p)
{
    if(l==r)
    {
        tree[p]=nw[l];
        return ;
    }
    bulid(l,mid,ls);
    bulid(mid+1,r,rs);
    up(p);
}
void update(int l,int r,int nl,int nr,int p,int k)
{
    if(l>=nl&&r<=nr)
    {
        tree[p]+=(r-l+1)*k;
        tree[p]%=mod;
        tag[p]+=k;
        return ;
    }
    down(l,r,p);
    if(mid>=nl)
    {
        update(l,mid,nl,nr,ls,k);
    }
    if(mid<nr)
    {
        update(mid+1,r,nl,nr,rs,k);
    }
    up(p);
}
long long query(int l,int r,int nl,int nr,int p)
{
    if(l>=nl&&r<=nr)
    {
        return tree[p]%mod;
    }
    long long res=0ll;
    down(l,r,p);
    if(mid>=nl)
    {
        res+=query(l,mid,nl,nr,ls);
    }
    if(mid<nr)
    {
        res+=query(mid+1,r,nl,nr,rs);
    }
    return res;
}

最后一步，利用nid数组的翻译来调用线段树

记住这个模板哦！

void upd_Range(int x,int y,int k)
{
    while(top[x]!=top[y])
    {
        if(dep[top[x]]<dep[top[y]])
            swap(x,y);
        你的操作
        x=fa[top[x]];
    }
    你的操作
}

调用！

long long q_Range(int x,int y)//询问一条路径
{
    long long ans=0ll;
    while(top[x]!=top[y])
    {
        if(dep[top[x]]<dep[top[y]])
            swap(x,y);
        ans=(ans+query(1,n,nid[top[x]],nid[x],1))%mod;
        x=fa[top[x]];
    }
    if(dep[x]>dep[y])
        swap(x,y);
    ans=(ans+query(1,n,nid[x],nid[y],1))%mod;
    return ans%mod;
}
long long q_Tree(int x)
{
    return query(1,n,nid[x],nid[x]+siz[x]-1,1)%mod;
}
void upd_Range(int x,int y,int k)
{
    k%=mod;
    while(top[x]!=top[y])
    {
        if(dep[top[x]]<dep[top[y]])
            swap(x,y);
        update(1,n,nid[top[x]],nid[x],1,k);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y])
        swap(x,y);
    update(1,n,nid[x],nid[y],1,k);
}
void upd_Tree(int x,int k)
{
    update(1,n,nid[x],nid[x]+siz[x]-1,1,k);
}

题目实例：P3384 【模板】轻重链剖分/树链剖分

ACcode

#include <bits/stdc++.h>
using namespace std;
#define ls p<<1
#define rs p<<1|1
#define mid ((l+r)>>1)
struct node{
    int nex,to;
};
const int N=1e5+10;
node edge[N<<1];
int head[N],tot;
void add(int from,int to){
    edge[++tot].nex=head[from];
    edge[tot].to=to;
    head[from]=tot;
}
int w[N],n,m,root,mod;//初始权值,n个节点，m个询问，根节点
int dep[N],fa[N],son[N],siz[N];//第一部分DFS
int top[N],nid[N],oid[N],nw[N],cnt;//第二部分DFS

int tree[N<<2],tag[N<<2];//线段树所需

void DFS1(int now,int fath){
    fa[now]=fath;
    siz[now]=1;
    son[now]=0;
    dep[now]=dep[fath]+1;
    for(int i=head[now];i;i=edge[i].nex){
        if(edge[i].to==fath)
            continue;
        DFS1(edge[i].to,now);
        siz[now]+=siz[edge[i].to];
        if(siz[son[now]]<siz[edge[i].to])
            son[now]=edge[i].to;
    }
}
void DFS2(int now,int topx){//topx，先重儿子再轻儿子
    top[now]=topx;
    nid[now]=++cnt;
    nw[cnt]=w[now];
    if(son[now])
        DFS2(son[now],topx);
    else
        return ;
    for(int i=head[now];i;i=edge[i].nex){
        if(edge[i].to!=fa[now]&&edge[i].to!=son[now])
            DFS2(edge[i].to,edge[i].to);
    }
}
int LCA(int x,int y){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]])
            swap(x,y);
        x=fa[top[x]];
    }
    return dep[x]<dep[y]?x:y;
}
//线段树部分
void up(int p){
    tree[p]=tree[ls]+tree[rs];
}
void down(int l,int r,int p){
    tag[ls]+=tag[p];
    tag[rs]+=tag[p];
    tree[ls]+=(mid-l+1)*tag[p];
    tree[ls]%=mod;
    tree[rs]+=(r-mid)*tag[p];
    tree[rs]%=mod;
    tag[p]=0;
}
void bulid(int l,int r,int p){
    if(l==r){
        tree[p]=nw[l];
        return ;
    }
    bulid(l,mid,ls);
    bulid(mid+1,r,rs);
    up(p);
}
void update(int l,int r,int nl,int nr,int p,int k){
    if(l>=nl&&r<=nr){
        tree[p]+=(r-l+1)*k;
        tree[p]%=mod;
        tag[p]+=k;
        return ;
    }
    down(l,r,p);
    if(mid>=nl)
        update(l,mid,nl,nr,ls,k);
    if(mid<nr)
        update(mid+1,r,nl,nr,rs,k);
    up(p);
}
int query(int l,int r,int nl,int nr,int p){
    if(l>=nl&&r<=nr)
        return tree[p]%mod;
    long long res=0ll;
    down(l,r,p);
    if(mid>=nl)
        res+=query(l,mid,nl,nr,ls);
    if(mid<nr)
        res+=query(mid+1,r,nl,nr,rs);
    return res;
}
//线段树完结
//线段树使用部分
int q_Range(int x,int y){
    long long ans=0ll;
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]])
            swap(x,y);
        ans=(ans+query(1,n,nid[top[x]],nid[x],1))%mod;
        x=fa[top[x]];
    }
    if(dep[x]>dep[y])
        swap(x,y);
    ans=(ans+query(1,n,nid[x],nid[y],1))%mod;
    return ans%mod;
}
int q_Tree(int x){
    return query(1,n,nid[x],nid[x]+siz[x]-1,1)%mod;
}
void upd_Range(int x,int y,int k){
    k%=mod;
    while(top[x]!=top[y])
    {
        if(dep[top[x]]<dep[top[y]])
            swap(x,y);
        update(1,n,nid[top[x]],nid[x],1,k);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y])
        swap(x,y);
    update(1,n,nid[x],nid[y],1,k);
}
void upd_Tree(int x,int k){
    update(1,n,nid[x],nid[x]+siz[x]-1,1,k);
}
signed main(){
    scanf("%d%d%d%d",&n,&m,&root,&mod);
    for(int i=1;i<=n;i++)
        scanf("%d",&w[i]);
    for(int i=1,l,r;i<=n-1;i++){
        scanf("%d%d",&l,&r);
        add(l,r);
        add(r,l);
    }
    DFS1(root,0);
    DFS2(root,root);
    bulid(1,n,1);
    for(int i=1;i<=m;i++){
        int c,x,y,k;
        scanf("%d",&c);
        if(c==1){
            scanf("%d%d%d",&x,&y,&k);
            upd_Range(x,y,k);
        }
        else if(c==2){
            scanf("%d%d",&x,&y);
            printf("%d\n",q_Range(x,y)%mod);
        }
        else if(c==3){
            scanf("%d%d",&x,&k);
            upd_Tree(x,k);
        }
        else{
            scanf("%d",&x);
            printf("%d\n",q_Tree(x)%mod);
        }
    }
	return 0;
}
追随远方的某R
关注
  • 18
    点赞
  • 踩
  • 77
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
树链剖分的总结
China__int128的博客
05-02 733
什么是树剖？here. 以下是它的一些基本概念： 关于树剖，最基本的就是求取 LCA，而他的时间复杂度到达了 O(logn)O(logn)O(logn)，虽说并比不上离线的 Tarjan 算法，只不过后者常数巨大，因此树剖便成为了不二之选。 首先理解一下树剖的过程： 我们假设一棵树它是长这样的。 不难发现，重链就是 1,4,9,12,13,141,4,9,12,13,141,4,9,12,13,14. 树链剖分求 LCA 的思想就是把一个图剖分成 lognlognlogn 条链，然后在链上进行跳跃。 综
树链剖分（轻重链剖分）
zixiangzhan的博客
10-25 625
树链剖分（轻重链剖分） 简介 树链剖分，简称”树剖“，顾名思义，就是将树“解剖”，将其转化成可用线段树维护的形式。由于线段树仅能进行区间上的操作，故需要通过一种划分方式，使得树链转化成区间，再用线段树维护。而“轻重儿子”的划分方式，不仅将树链转化成区间，还保证了该算法的复杂度。该算法可以用小常数n*log2 (n)的时间复杂度，维护一颗形态固定的树的树上路径信息，如对一段路径上的点进行修改，询问一段路径上所有点的权值和等等。值得一提的是，该算法还顺便可以用于求出两点之间的LCA.复杂度也为log，并且求L
【数据结构】树链剖分
Video_game的博客
12-11 1209
树链剖分
树剖的总结
cn_tigerhan的博客
10-28 650
jjj
树链剖分
weixin_30724853的博客
10-08 213
树链剖分看起来是个很高级的算法，但实际上很简单。在介绍这个算法之前，要感谢某位大神cgh，是他教了我树链剖分。 简介 什么样的题目要...
树链剖分瞎入门
Venus的博客
01-09 407
本文旨在让读者背代码 前言 在做题时，我们可能会遇到这样一类问题： 给定一棵 nnn 个结点的树和 mmm 次操作，操作有两种，一种是给定两个结点，让连接两个结点的路径上的所有点权值加上一个值，另一种是查询路径上所有点的权值和。n≤1e5n\le 1e5n≤1e5，m≤2e5m\le 2e5m≤2e5。 如果是最后统一输出结点权值，用树上差分+DFS\text{DFS}DFS 就能轻松水过，而...
NOIP 树链剖分 NOIP 树链剖分
10-30
NOIP 树链剖分 NOIP 树链剖分
树链剖分算法.pptx
09-03
树链剖分，计算机术语，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链
树链剖分模板题
05-19
#include #include #include #define N 30003 #define INF 2147483647 using namespace std; int n,f[N][20],dep[N],siz[N],son[N],top[N],tot,pos[N],w[N]; int Max[N*4],Sum[N*4];...vector <int> to[N];...
第5章 树链剖分 测试数据.rar
12-02
树链剖分是一种高效处理树型结构的算法，尤其在解决与树的边查询和修改有关的问题时，它能提供显著的效率提升。这一技术在信息学奥赛中经常被用到，帮助参赛者快速解决复杂的树形问题。在本章的测试数据中，你将有...
树链博弈：链式向前星
m0_70056095的博客
05-14 143
现在小 Bo 和小 Biao 要进行博弈，他们两轮流操作，每次选择一个黑色的结点将它变白，之后可以选择任意多个(可以不选)该点的祖先(不包含自己)，然后将这些点的颜色翻转，不能进行操作的人输由于小 Bo 猜拳经常输给小 Biao，他想在这个游戏上扳回一城，现在他想问你给定了一个初始局面，是先手必胜还是后手必胜。遍历方式：难点应该是第二层循环：它的意思是从第i个结点为起点的最后一个终点往前遍历直到找到初始值为-1（edge[i].next,存的是上一条边的相同起点的边的编号，-1表示上一条没有边了）
【数据结构】树链剖分 (图文代码详解)
qq_49688477的博客
08-09 1272
树链剖分算法图文详解
【模板】树链剖分
cbdsopa的博客
10-09 81
原文 相当于把树上的链抽出来变成区间进行操作。 重链剖分（本文重点）： 本文依照P3384 【模板】轻重链剖分/树链剖分的实现进行讲解。 就是剖分出重链覆盖全树。 重链：除开头的端点为轻儿子外，其他节点全为重儿子的链。 重儿子：一个节点的儿子中子树大小最大的儿子。 要进行树链剖分，先要进行预处理。需要处理出以下信息： top[u]top[u]top[u] u节点所在重链的开头端点的编号。 dep[u]dep[u]dep[u] u节点的深度。 fa[u]fa[u]fa[u] u节点的父亲节点的编号。 dfn
链式前向星，字典树（Trie），01字典树，cin关闭流同步的与cout的endl使用
m0_75027890的博客
01-10 385
链式前向星，字典树（Trie），01字典树，cin关闭流同步的与cout的endl使用
链式前向星存树图和遍历它的两种方法【dfs、bfs】
XJHui
08-07 2705
目录 一、链式前向星存图 二、两种遍历方法 一、链式前向星存图:（n个点，n-1条边） 链式前向星把上面的树图存下来，输入： 9 ///代表要存进去n个点 1 2 ///下面是n-1条边，每条边连接两个点 1 3 1 7 2 4 4 5 4 6 3 8 3 9 1、先把链式前向星想成链表，建成后（存双向边）： （数字代表竖线前的点与后面的点相连，1-2、1-3 都是表示边...
POJ3321 Apple Tree（链式前向星+DFS序+树状数组）
Happig的博客
03-06 233
题目链接 There is an apple tree outside of kaka’s house. Every autumn, a lot of apples will grow in the tree. Kaka likes apple very much, so he has been carefully nurturing the big apple tree.The tree has...
【18】输出字符菱形
最新发布
2301_78786609的博客
07-19 365
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Aragorn 树链剖分
09-24
Aragorn 树链剖分是一种将一棵树剖分为若干条链的算法，然后利用数据结构去维护每一条链的技术。剖分完毕后，每条重链相当于一段区间，然后可以使用数据结构去维护整个树。具体过程是通过两次深度优先搜索来实现的：第一次DFS找出每个节点的子树大小和重儿子，第二次DFS连接重边形成重链。在重链上的节点使用数据结构维护，而不在当前重链上的节点，重新拉一条重链并维护。这样可以实现对树进行高效的查询和修改操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值