树链剖分

最新推荐文章于 2024-03-25 09:04:56 发布
最新推荐文章于 2024-03-25 09:04:56 发布
阅读量105 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shaohang_/article/details/96157123
版权

第一次学树剖，推荐一篇大佬博客：https://www.cnblogs.com/KatouKatou/p/9557540.html

树剖关键代码：

void dfs1(int u,int f){
    sze[u]=1;
    for (int i=head[u];~i;i=edge[i].nxt){
        int v=edge[i].v;
        if(v==f)continue;
        dep[v]=dep[u]+1;fa[v]=u;
        dfs1(v,u);
        sze[u]+=sze[v];
        if (sze[v]>sze[son[u]])son[u]=v;
    }
}
void dfs2(int u,int Top)
{
    dfn[u]=++cnt;///按重链优先编号,使重儿子连续
    rk[cnt]=u;
    top[u]=Top;
    if(son[u]) dfs2(son[u],Top);///继续递归u的重儿子,故重链顶端还是Top
    for(int i=head[u];~i;i=edge[i].nxt){
        int v=edge[i].v;
        if(v!=fa[u]&&v!=son[u])///既不是u的父亲，也不是u的重儿子时，说明v只可能是u的轻儿子
            dfs2(v,v);///轻儿子的Top还是自己
    }
}

核心：树链剖分就是将树分割成多条链，然后利用数据结构（线段树、树状数组等）来维护这些链。 关键是利用top的加速。

例题：https://www.luogu.org/problemnew/show/P2590

分析：显然是线段树维护树链剖分，支持单点修改，区间查询最大值，区间求和。

每个数组的含义：

sze[i]：以i为根结点的子树的所有结点数。

fa[i]：i结点的父结点

son[i]：i结点的重儿子

top[i]：i结点的重链顶端结点

dep[i]：i结点的深度，dep[1]=1

dfn[i]： i结点的dfs序编号

rk[i]：dfs序编号为i的结点在原来树中对应的编号

Ac code:

///线段树维护树链剖分
#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+10;
int a[maxn],tot,cnt,n;
int head[maxn];
struct Edge{
    int v,nxt;
}edge[maxn<<1];
int sze[maxn],fa[maxn],son[maxn],top[maxn],dep[maxn];
int dfn[maxn],rk[maxn];
const int INF=1e9;
struct Tree{
    int _max;
    int sum;
}tree[maxn<<2];
void init()
{
    cnt=0;
    tot=0;
    dep[1]=1;
    memset(head,-1,sizeof head);
}
void addedge(int u,int v)
{
    edge[tot].v=v;
    edge[tot].nxt=head[u];
    head[u]=tot++;
}
void dfs1(int u,int f){
    sze[u]=1;
    for (int i=head[u];~i;i=edge[i].nxt){
        int v=edge[i].v;
        if(v==f)continue;
        dep[v]=dep[u]+1;fa[v]=u;
        dfs1(v,u);
        sze[u]+=sze[v];
        if (sze[v]>sze[son[u]])son[u]=v;
    }
}
void dfs2(int u,int Top)
{
    dfn[u]=++cnt;///按重链优先编号,使重儿子连续
    rk[cnt]=u;
    top[u]=Top;
    if(son[u]) dfs2(son[u],Top);
    for(int i=head[u];~i;i=edge[i].nxt){
        int v=edge[i].v;
        if(v!=fa[u]&&v!=son[u])
            dfs2(v,v);
    }
}
void pushup(int rt)
{
    tree[rt].sum=tree[rt<<1].sum+tree[rt<<1|1].sum;
    tree[rt]._max=max(tree[rt<<1]._max,tree[rt<<1|1]._max);
}
void buildtree(int rt,int l,int r)
{
    if(l==r){
        tree[rt].sum=a[rk[l]];
        tree[rt]._max=a[rk[l]];///注意是在原来树中对应的编号
        return;
    }
    int mid=(l+r)>>1;
    buildtree(rt<<1,l,mid);
    buildtree(rt<<1|1,mid+1,r);
    pushup(rt);
}
void update(int rt,int l,int r,int p,int val)
{
    if(l==r){
        tree[rt].sum=val;
        tree[rt]._max=val;
        return;
    }
    int mid=(l+r)>>1;
    if(p<=mid) update(rt<<1,l,mid,p,val);
    else update(rt<<1|1,mid+1,r,p,val);
    pushup(rt);
}
int query_max(int rt,int l,int r,int L,int R)
{
    if(L<=l&&r<=R){
        return tree[rt]._max;
    }
    int ans=-INF;
    int mid=(l+r)>>1;
    if(mid>=L) ans=max(ans,query_max(rt<<1,l,mid,L,R));
    if(mid<R) ans=max(ans,query_max(rt<<1|1,mid+1,r,L,R));
    pushup(rt);
    return ans;
}
int query_sum(int rt,int l,int r,int L,int R)
{
    if(L<=l&&r<=R){
        return tree[rt].sum;
    }
    int ans=0;
    int mid=(l+r)>>1;
    if(mid>=L) ans+=query_sum(rt<<1,l,mid,L,R);
    if(mid<R) ans+=query_sum(rt<<1|1,mid+1,r,L,R);
    pushup(rt);
    return ans;
}
int qmax(int u,int v)
{
    int ans=-INF;
    while(top[u]!=top[v]){
        if(dep[top[u]]<dep[top[v]]) swap(u,v);
        ans=max(ans,query_max(1,1,n,dfn[top[u]],dfn[u]));///更新重链顶端到u的每个结点的值
        u=fa[top[u]];///top[u]!=top[v],此时深的结点u应跳到top[u]的父节点
    }
    if(dep[u]<dep[v]) swap(u,v);
    ans=max(ans,query_max(1,1,n,dfn[v],dfn[u]));
    return ans;
}
int qsum(int u,int v)
{
    int ans=0;
    while(top[u]!=top[v]){
        if(dep[top[u]]<dep[top[v]]) swap(u,v);
        ans+=query_sum(1,1,n,dfn[top[u]],dfn[u]);
        u=fa[top[u]];///top[u]!=top[v],此时深的结点u应跳到top[u]的父节点
    }
    if(dep[u]<dep[v]) swap(u,v);
    ans+=query_sum(1,1,n,dfn[v],dfn[u]);
    return ans;
}
int main()
{
    int m,u,v;
    scanf("%d",&n);
    init();
    for(int i=1;i<=n-1;i++){
        scanf("%d%d",&u,&v);
        addedge(u,v);
        addedge(v,u);
    }
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    fa[1]=1;
    dfs1(1,-1);
    dfs2(1,1);
    buildtree(1,1,n);
    scanf("%d",&m);
    char op[10];
    while(m--){
        scanf("%s%d%d",op,&u,&v);
        if(op[1]=='H'){
            update(1,1,n,dfn[u],v);
        }
        else if(op[1]=='M'){
            printf("%d\n",qmax(u,v));
        }
        else{
            printf("%d\n",qsum(u,v));
        }
    }
    return 0;
}

 

再来个模板题

例题：https://www.luogu.org/problemnew/show/P3384

分析：需要完成四种操作。

1、路径修改

2、路径查询

3、子树修改

4、子树查询

1，2直接可以树链剖分+线段树完成

3，4不需要树剖，找到需要查询子树的根结点和该子树dfs最后一个结点的编号即可，即对区间[dfn[u]，dfn[u]+sze[u]-1]进行操作

dfn[u]为dfs序编号。

Ac code:

/P3384
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e5+10;
int head[maxn],a[maxn],n;
struct Edge{
    int v,nxt;
}edge[maxn<<1];
int tot,cnt;
int fa[maxn],son[maxn],dfn[maxn],rk[maxn],sze[maxn],dep[maxn],top[maxn];
int p;
struct Tree{
    int val,lazy;
}tree[maxn<<2];
void init()
{
    tot=cnt=0;
    memset(head,-1,sizeof head);
}
void addedge(int u,int v)
{
    edge[tot].v=v;
    edge[tot].nxt=head[u];
    head[u]=tot++;
}
void dfs1(int u,int faa)
{
    sze[u]=1;
    for(int i=head[u];~i;i=edge[i].nxt)
    {
        int v=edge[i].v;
        if(v==faa) continue;
        fa[v]=u;
        dep[v]=dep[u]+1;
        dfs1(v,u);
        sze[u]+=sze[v];
        if(sze[v]>sze[son[u]])
            son[u]=v;
    }
}
void dfs2(int u,int Top)
{
    dfn[u]=++cnt;
    rk[cnt]=u;
    top[u]=Top;
    if(son[u]) dfs2(son[u],Top);
    for(int i=head[u];~i;i=edge[i].nxt){
        int v=edge[i].v;
        if(v!=fa[u]&&v!=son[u]){
            dfs2(v,v);
        }
    }
}
int lca(int u,int v)
{
    while(top[u]!=top[v])
    {
        if(dep[top[u]]>dep[top[v]])
            u=fa[top[u]];
        else
            v=fa[top[v]];
    }
    return dep[u]<dep[v]?u:v;
}
void pushup(int rt)
{
    tree[rt].val=tree[rt<<1].val+tree[rt<<1|1].val;
}
void pushdown(int rt,int l,int r)
{
    int len=r-l+1;
    if(tree[rt].lazy){
        tree[rt<<1].lazy+=tree[rt].lazy;
        tree[rt<<1].val+=tree[rt].lazy*(len-(len>>1));
        tree[rt<<1|1].lazy+=tree[rt].lazy;
        tree[rt<<1|1].val+=tree[rt].lazy*(len>>1);
        tree[rt<<1].val%=p;
        tree[rt<<1|1].val%=p;
        tree[rt].lazy=0;
    }
}
void buildtree(int rt,int l,int r)
{
    if(l==r){
        tree[rt].val=a[rk[l]]%p;
        tree[rt].lazy=0;
        return;
    }
    int mid=(l+r)>>1;
    buildtree(rt<<1,l,mid);
    buildtree(rt<<1|1,mid+1,r);
    pushup(rt);
}
void update(int rt,int l,int r,int L,int R,int val)
{
    if(L<=l&&r<=R){
        tree[rt].lazy+=val;
        tree[rt].val+=val*(r-l+1);
        return;
    }
    pushdown(rt,l,r);
    int mid=(l+r)>>1;
    if(mid>=L) update(rt<<1,l,mid,L,R,val);
    if(mid<R) update(rt<<1|1,mid+1,r,L,R,val);
    pushup(rt);
}
int query(int rt,int l,int r,int L,int R)
{
    if(L<=l&&r<=R){
        return tree[rt].val%p;
    }
    pushdown(rt,l,r);
    int mid=(l+r)>>1;
    int ans=0;
    if(mid>=L) ans=(ans+query(rt<<1,l,mid,L,R))%p;
    if(mid<R) ans=(ans+query(rt<<1|1,mid+1,r,L,R))%p;
    return ans;
}


int qrange(int u,int v)
{
    int ans=0;
    while(top[u]!=top[v]){
        if(dep[top[u]]<dep[top[v]]) swap(u,v);
        ans=(ans+query(1,1,n,dfn[top[u]],dfn[u]))%p;
        u=fa[top[u]];
    }
    if(dep[u]<dep[v]) swap(u,v);
    ans=(ans+query(1,1,n,dfn[v],dfn[u]))%p;
    return ans;
}
void uprange(int u,int v,int val)
{
    while(top[u]!=top[v]){
        if(dep[top[u]]<dep[top[v]]) swap(u,v);
        update(1,1,n,dfn[top[u]],dfn[u],val);
        u=fa[top[u]];
    }
    if(dep[u]<dep[v]) swap(u,v);
    update(1,1,n,dfn[v],dfn[u],val);
}
int qson(int u)
{
    return query(1,1,n,dfn[u],dfn[u]+sze[u]-1)%p;
}
void upson(int u,int val)
{
    update(1,1,n,dfn[u],dfn[u]+sze[u]-1,val);
}
int main()
{
    int m,r;
    scanf("%d%d%d%d",&n,&m,&r,&p);
    init();
    dep[r]=1;
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    int u,v;
    for(int i=1;i<n;i++)
    {
        scanf("%d%d",&u,&v);
        addedge(u,v);
        addedge(v,u);
    }
    fa[r]=0;
    dfs1(r,0);
    dfs2(r,r);
    buildtree(1,1,n);
    for(int i=1;i<=n;i++) cout<<"top="<<rk[i]<<' '<<sze[i]<<endl;
    int op,x,y,z;
    while(m--){
        scanf("%d",&op);
        if(op==1){
            scanf("%d%d%d",&x,&y,&z);
            uprange(x,y,z);
        }
        else if(op==2){
            scanf("%d%d",&x,&y);
            printf("%d\n",qrange(x,y)%p);
        }
        else if(op==3){
            scanf("%d%d",&x,&z);
            upson(x,z);
        }
        else{
            scanf("%d",&x);
            printf("%d\n",qson(x)%p);
        }
    }
    return 0;
}

 

HangShao99
关注
专栏目录
树链剖分详解
算法小猪的博客
08-13 1336
目录一、树链剖分相关概念1.为啥要剖分2.轻边和重边3.轻重边路径剖分的性质二、树链剖分的实现1.重链剖分 一、树链剖分相关概念 1.为啥要剖分 1.可以维护树路径上的信息(维护) 2.将一棵树划分成若干条链，用数据结构去维护每条链，复杂度为O(logN)O(logN)O(logN)。(复杂度低) 2.轻边和重边 将树中的边分为：轻边和重(zhong)边 定义size(x)size(x)size(x)为以xxx为根的子树的节点个数。 令vvv为xxx的儿子节点中sizesizesize值最大的节点，那么边(
树链剖分总结
ZhuRanCheng的博客
05-22 646
树链剖分总结
树链剖分（重链剖分）
m0_73666576的博客
03-24 2041
本文主要针对于还没有学习过这个算法的新手同学
树链剖分 模板小记
绫
07-21 142
树链剖分 模板小记树链剖分~模板小记树链剖分 模板小记 Q.Q.Q. 树链剖分的背景？ A.A.A. 连通且无环的树 Q.Q.Q. 树链剖分的作用？ A.A.A. 大幅增加码量 （ A.A.A. 将一棵树变成几条链 树形变成线形 减少处理难度 Q.Q.Q. 树链剖分能处理哪些问题？ A1.A_1.A1​. 修改的有： 将xxx节点+ or×val+~or\times val+ or×val 将xxx到yyy这条路径上所有节点+ or×val+~or\t
191028-树链剖分
Daniel__d的博客
10-31 220
191028-树链剖分 定义 指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链。 那么什么是轻重边呢？ 很简单，来看下面一张图： 在轻重链剖分中，每个非叶节点有且仅有一个重儿子，其余子节点为轻儿子。轻重儿子划分的依据是子树大小，对于每个非叶节点， 其子树size最大的子节点成为...
树链剖分（重链剖分）总结
x052xiao的博客
11-06 131
树链剖分（重链剖分）总结
树链剖分 求 最近公共祖先（LCA)
最新发布
qq_37746591的博客
03-25 1090
用树链刨分求最近公共祖先的笔记
【数据结构】树链剖分
Video_game的博客
12-11 1370
树链剖分
第5章 树链剖分 测试数据.rar
12-02
树链剖分是一种高效处理树型结构的算法，尤其在解决与树的边查询和修改有关的问题时，它能提供显著的效率提升。这一技术在信息学奥赛中经常被用到，帮助参赛者快速解决复杂的树形问题。在本章的测试数据中，你将有...
NOIP 树链剖分 NOIP 树链剖分
10-30
### NOIP 树链剖分知识点详解 #### 一、树链剖分的相关概念 **剖分目的**：树链剖分的主要目的是为了更高效地处理树状结构上的路径信息维护问题，例如路径上的权值更新或查询等操作。通过树链剖分，可以将这些操作...
树链剖分（含例题）
zyc_____的博客
05-04 447
树链剖分介绍： 模板题：【模板】最近公共祖先（LCA） - 洛谷 图片来自：通俗易懂的树链剖分详解 - 一剑缥缈的洛咕博客 - 洛谷博客 树链剖分的优点： 求LCA中的优化无非就是减少无效搜索的次数，树链剖分把树拆成不同的链（保证不重不漏），因为两个点的LCA一定在一条链上（同一个点），所以如果搜索到的点不在同一条链上，那么不是倍增跳或是······，而是跳过一整条链，这样搜索的速度会大幅提高。 注释代码： #include<bits/stdc++.h> using names.
分块（真的是优雅的暴力）
shaohang_的博客
07-24 1429
M - 一道普通题1 给出一个长为n​的数列，以及n​个操作，操作涉及区间加法，询问区间内小于某个值x​的前驱（比其小的最大元素）。 Input 第一行输入一个数字n,1≤n≤100000。 第二行输入n个非负整数，第ii个数字为ai(0≤ai≤10^9)以空格隔开。 接下来输入n行询问，每行输入四个数字opt、l、r、c(c>0)，以空格隔开。 若 op...
离散化+线段树
shaohang_的博客
03-18 995
题目：http://acm.hdu.edu.cn/showproblem.php?pid=6464 分析： 每次1操作会往序列底加first个second，first 和 second 都是最大1e9的数据，每次2操作询问序列中第first到第second个数的和 一开始就感觉有点像线段树，输入数据太大我们可以离线处理把数据离散化下，然后扔到线段树上，维护两个数组： sum: 区间数的值的...
二分+线段树
shaohang_的博客
04-07 533
题目： C. Store time limit per test 1.0 s memory limit per test 256 MB Ichuan is a store owner and his store has n products, numbered from11tonn. Recently, his business is not very good, and he c...
DAG的最短路
shaohang_的博客
01-27 529
题目：https://ac.nowcoder.com/acm/contest/329/B 分析：由于带负权，肯定不能用Dijkstra,用spfa可高效解决，但是特殊 DAG 的性质使得 SPFA 算法无法在规定的时间限内求解出答案，此时由DAG的拓扑序列可以很好解决该问题。 因此，放弃vis数组，以拓扑序列来入队 Ac code: #include&lt;bits/stdc++.h&g...
LCA的应用
shaohang_的博客
07-15 524
1、多次询问求树上两个点的距离 例题：hdu2586http://acm.hdu.edu.cn/showproblem.php?pid=2586 分析：LCA的板子题，关键利用dist[u,v]=dist[1,u]+dist[1,v]-2*dist[1,lca(u,v)]; Ac code: #include<bits/stdc++.h> using namespace s...
0-1字典树
shaohang_的博客
01-13 295
题目：http://acm.hdu.edu.cn/showproblem.php?pid=5536 题意：给你n个数，要找三个不同的数a[i],a[j],a[k]使(a[i]+a[j])^a[k]最大，求最大值 分析：对于异或的最大值问题，一般考虑用01字典树，先把这n个数插入字典树中，然后直接枚举a[i]+a[j],并从字典树中暂时删除a[i],a[j],在字典树中直接找与(a[i]+a[j...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值