P3384【模板】重链剖分/树链剖分 题解

已于 2023-04-05 10:05:41 修改
阅读量97 收藏
点赞数 1
分类专栏： 题解 文章标签： 算法 c++
于 2023-04-05 10:00:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lv_jia_qi/article/details/129965992
版权

题目传送门

思路

初看题目，这题应该是一个线段树

但是，这题的存储结构怎么是树啊啊啊

于是，我们可能会想到把树分解成若干条链，在进行操作，这就是题目中说的树链剖分

树链剖分

常用于解决静态树上路径信息。

核心：如何恰当地将树剖分为若干条链。
常见剖分方式 ：
  • 重链剖分
  • 长链剖分
  • 虚链剖分

这里我们只介绍重链剖分

对树的边进行分类
  • 重边
  • 轻边
以任意点为根，记 size(u) 以 u 为根节点的子树的结点总数。令 v 是 u 的所有
儿子节点中 size 值最大的， u-v 边称为重边，其他就是轻边。
由重边构成的链，称为重链。单个的视为长度为 1 的。
性质
  1.  如果 (u,v) 为轻边，那么 size(v) ≤ size(u)/2
  2.  从根到某个节点v的路径上的轻边个数不多于 log n
  3.  当某个链全部由重链组成。对于每个结点到根的路径上都有不超过 log n 条轻边和 log n 条重路径

整体复杂度O(log^2n)

预处理

两次 DFS
DFS1 : 建树
DFS2: 剖分
第 1 次 DFS 中需要维护
  • dep[u] 深度
  • fa[u] 父节点信息
  • siz[u] 以u为根节点的子树的总结点数
  • son[u] : u的重儿子

代码如下：

void dfs1(int u,int f)
{
    dep[u]=dep[f]+1;
    fa[u]=f;
    siz[u]=1;
    for(auto v:G[u])
    {
        if(v==f) continue;
        dfs1(v,u);
        siz[u]+=siz[v];
        if(!son[u] ||siz[son[u]]<siz[v])
        {
            son[u]=v;
        }
    }
}
第 2 次 DFS
  • top[u] u 所在重链上的顶端结点编号
  • id[u] u 在结点序列中的位置下标，也就是时间戳（id数组在一些简单题里可以不用）
代码如下： 
void dfs2(int u,int topu)
{
    top[u]=topu;
    id[u]=++dfn;
    a[dfn]=ori[u];
    if(!son[u]) return ;
    dfs2(son[u],topu);
    for(auto v:G[u])
    {
        if(v==fa[u] || v==son[u]) continue;
        dfs2(v,v);
    }
}

这时我们注意到，我们所要处理的所有区间均为连续编号，于是想到线段树，用线段树处理连续编号区间和

代码如下：

const int N=1e5+5;
int n,m;
int ori[N],a[N];
vector<int> G[N];
int w[N<<2],lzy[N<<2];

void pushup(int u){
    w[u]=w[2*u]+w[2*u+1];
}

void build(int u,int L,int R){
    lzy[u]=0;
    if(L==R){
        w[u]=a[L];
        return ;
    }
    int mid=(L+R)>>1;
    build(2*u,L,mid);
    build(2*u+1,mid+1,R);
    pushup(u);
}
bool inRange(int l,int r,int L,int R){
    return (l<=L)&&(R<=r);
}
bool outofRange(int l,int r,int L,int R){
    return r<L||R<l;
}

void makeTag(int u,int len,int x){
    lzy[u]+=x;
    w[u]+=len*x;
}
void pushdown(int u,int l,int r){
    int mid=(l+r)/2;
    makeTag(2*u,mid-l+1,lzy[u]);
    makeTag(2*u+1,r-mid,lzy[u]);
    lzy[u]=0;
}
void update(int u,int l,int r,int L,int R,int x){
    if(inRange(L,R,l,r)){
        makeTag(u,r-l+1,x);
    }else if(!outofRange(L,R,l,r)){
        int mid=(l+r)/2;
        pushdown(u,l,r);
        update(2*u,l,mid,L,R,x);
        update(2*u+1,mid+1,r,L,R,x);
        pushup(u);
    }
}
int query(int u,int l,int r,int L,int R){
    if(inRange(L,R,l,r)){
        return w[u];
    }else if(!outofRange(L,R,l,r)){
        int mid=(l+r)/2;
        pushdown(u,l,r);
        return (query(2*u,l,mid,L,R)+query(2*u+1,mid+1,r,L,R));
    }else{
        return 0;
    }
}
int dep[N],fa[N],siz[N],son[N],top[N],id[N];
int dfn;
void dfs1(int u,int f){
    dep[u]=dep[f]+1;
    fa[u]=f;
    siz[u]=1;
    for(auto v:G[u]){
        if(v==f) continue;
        dfs1(v,u);
        siz[u]+=siz[v];
        if(!son[u] ||siz[son[u]]<siz[v]){
            son[u]=v;
        }
    }
}
void dfs2(int u,int topu){
    top[u]=topu;
    id[u]=++dfn;
    a[dfn]=ori[u];
    if(!son[u]) return ;
    dfs2(son[u],topu);
    for(auto v:G[u]){
        if(v==fa[u] || v==son[u]) continue;
        dfs2(v,v);
    }
}
void updateRange(int x,int y,int z){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        update(1,1,n,id[top[x]],id[x],z);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y]) swap(x,y);
    update(1,1,n,id[x],id[y],z);
}
int queryRange(int x,int y){
    int ans=0;
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        ans+=query(1,1,n,id[top[x]],id[x]);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y]) swap(x,y);
    ans+=query(1,1,n,id[x],id[y]);
    return ans;
}

void updateTree(int x,int k){
    update(1,1,n,id[x],id[x]+siz[x]-1,k);
}
int queryTree(int x){
    return query(1,1,n,id[x],id[x]+siz[x]-1);
}

Code

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N=1e5+5;
int n,m;
int ori[N],a[N];
vector<int> G[N];
int w[N<<2],lzy[N<<2];

void pushup(int u){
    w[u]=w[2*u]+w[2*u+1];
}

void build(int u,int L,int R){
    lzy[u]=0;
    if(L==R){
        w[u]=a[L];
        return ;
    }
    int mid=(L+R)>>1;
    build(2*u,L,mid);
    build(2*u+1,mid+1,R);
    pushup(u);
}
bool inRange(int l,int r,int L,int R){
    return (l<=L)&&(R<=r);
}
bool outofRange(int l,int r,int L,int R){
    return r<L||R<l;
}

void makeTag(int u,int len,int x){
    lzy[u]+=x;
    w[u]+=len*x;
}
void pushdown(int u,int l,int r){
    int mid=(l+r)/2;
    makeTag(2*u,mid-l+1,lzy[u]);
    makeTag(2*u+1,r-mid,lzy[u]);
    lzy[u]=0;
}
void update(int u,int l,int r,int L,int R,int x){
    if(inRange(L,R,l,r)){
        makeTag(u,r-l+1,x);
    }else if(!outofRange(L,R,l,r)){
        int mid=(l+r)/2;
        pushdown(u,l,r);
        update(2*u,l,mid,L,R,x);
        update(2*u+1,mid+1,r,L,R,x);
        pushup(u);
    }
}
int query(int u,int l,int r,int L,int R){
    if(inRange(L,R,l,r)){
        return w[u];
    }else if(!outofRange(L,R,l,r)){
        int mid=(l+r)/2;
        pushdown(u,l,r);
        return (query(2*u,l,mid,L,R)+query(2*u+1,mid+1,r,L,R));
    }else{
        return 0;
    }
}
int dep[N],fa[N],siz[N],son[N],top[N],id[N];
int dfn;
void dfs1(int u,int f){
    dep[u]=dep[f]+1;
    fa[u]=f;
    siz[u]=1;
    for(auto v:G[u]){
        if(v==f) continue;
        dfs1(v,u);
        siz[u]+=siz[v];
        if(!son[u] ||siz[son[u]]<siz[v]){
            son[u]=v;
        }
    }
}
void dfs2(int u,int topu){
    top[u]=topu;
    id[u]=++dfn;
    a[dfn]=ori[u];
    if(!son[u]) return ;
    dfs2(son[u],topu);
    for(auto v:G[u]){
        if(v==fa[u] || v==son[u]) continue;
        dfs2(v,v);
    }
}
void updateRange(int x,int y,int z){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        update(1,1,n,id[top[x]],id[x],z);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y]) swap(x,y);
    update(1,1,n,id[x],id[y],z);
}
int queryRange(int x,int y){
    int ans=0;
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        ans+=query(1,1,n,id[top[x]],id[x]);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y]) swap(x,y);
    ans+=query(1,1,n,id[x],id[y]);
    return ans;
}

void updateTree(int x,int k){
    update(1,1,n,id[x],id[x]+siz[x]-1,k);
}
int queryTree(int x){
    return query(1,1,n,id[x],id[x]+siz[x]-1);
}

signed main()
{
    int x,y,z,op;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d",&ori[i]);
    }
    for(int i=1;i<n;i++){
        scanf("%d%d",&x,&y);
        G[x].push_back(y);
        G[y].push_back(x);
    }
    dfs1(1,0);
    dfs2(1,1);
    build(1,1,n);
    while(m--){
        scanf("%d",&op);
        switch(op){
            case 1:scanf("%d%d",&x,&z);
                updateRange(x,x,z);
                break;
            case 2:scanf("%d%d",&x,&z);
                updateTree(x,z);
                break;
            case 3:scanf("%d",&x);
                printf("%d\n",queryRange(1,x));
        }
    }
	return 0;
}

lv_jia_qi
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
P3384 【模板】树链剖分
weixin_34075551的博客
12-31 127
P3384 【模板】树链剖分 题目描述 如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作： 操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 操作2： 格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和 操作3： 格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z 操作4： 格式： ...
P3384(树链剖分，入门，模板）
qq_39861441的博客
04-04 202
题目描述 题目详见：https://www.luogu.org/problemnew/show/P3384 如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作： 操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 操作2： 格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和 操作3： 格式： 3 x z...
P3384 【模板】轻重链剖分/树链剖分
qq_53504307的博客
08-02 143
代码】P3384 【模板】轻重链剖分/树链剖分。
P3384 【模板】轻重链剖分(树剖)
Harris-H的博客
03-23 301
P3384 【模板】轻重链剖分(树剖) 题意 给定树：树链修改，树链求和，子树修改，子树求和。 思路 树链剖分裸题。 树剖保证了重链编号连续，子树编号连续，然后可转化为区间问题，上个线段树即可。 code // Problem: P3384 【模板】轻重链剖分 // Contest: Luogu // URL: https://www.luogu.com.cn/problem/P3384 // Memory Limit: 125 MB // Time Limit: 1000 ms // Date: 2021
洛谷 P3384 【模板】轻重链剖分/树链剖分
最新发布
月半流苏的博客
10-28 273
如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作： - 1 x y z，表示将树从x到y结点最短路径上所有节点的值都加上z。 - 2 x y，表示求树从x到y结点最短路径上所有节点的值之和。 - 3 x z，表示将以x为根节点的子树内所有节点值都加上z。 - 4 x 表示求以x为根节点的子树内所有节点值之和
NOIP 树链剖分 NOIP 树链剖分
10-30
**重链剖分**：这是一种常见的树链剖分方式，其过程包括两次深度优先搜索（DFS）： 1. **找重边**：通过一次 DFS，记录所有重边。 - 函数 `FIND-HEAVY_EDGE(x, father, depth)` 可用于查找重边。 - 在这个过程中...
第5章 树链剖分 测试数据.rar
12-02
树链剖分是一种高效处理树型结构的算法，尤其在解决与树的边查询和修改有关的问题时，它能提供显著的效率提升。这一技术在信息学奥赛中经常被用到，帮助参赛者快速解决复杂的树形问题。在本章的测试数据中，你将有...
树链剖分模板题
05-19
if(P)update(k*2,l,mid,P,V); else update(k*2+1,mid+1,r,P,V); Max[k]=max(Max[k*2],Max[k*2+1]); Sum[k]=Sum[k*2]+Sum[k*2+1]; } void up(int &x,int goal){ for(int i=15;i>=0;--i) if(dep[f[x][i]]>=goal...
树链剖分算法.pptx
09-03
树链剖分，计算机术语，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链
树链剖分_题解_
10-03
本题解将详细介绍树链剖分的概念、实现原理以及其在 luoguP3384 题目中的应用。 首先，我们来理解树链剖分的基本思想。给定一棵树，我们希望将其分割成若干个尽可能短的链，使得每个节点到根节点的路径上只经过了...
树链剖分 洛谷p3384
MrTinTin的博客
08-24 267
题目描述 如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作： 操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 操作2： 格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和 操作3： 格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z 操作4： 格式： 4 x 表示求以x为根节点的子树
洛谷3384 树链剖分
YHaX的博客
10-30 627
树链剖分+dfs序
树链剖分（P3384）
shadiao.的博客
10-12 134
树链剖分的作用 树链剖分用于解决树上区间询问，主要有两种： 给出两点，询问和修改之间的路径， 又或者给出一个点，询问和修改整颗子树的信息。 树链剖分需要配合其他数据结构如线段树等一起使用 说白了，树链剖分只是根据询问提供正确的区间 针对路径给出区间 的 复杂度为O（logN） 针对子树给出区间 的 复杂度为O（1） 如何实现？ 树链剖分，顾名思义，就是把树分成链。 分为重链和...
洛谷 P3384 树链剖分(详解)
riba2534的博客
07-12 3949
题目描述 如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作： 操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 操作2： 格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和 操作3： 格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z 操作4： 格...
洛谷 P3384 【模板】树链剖分
sdfzrlt的博客
04-14 970
树链剖分
【P3384】【模板】树链剖分
Flanoc的博客
07-05 427
树链剖分模板
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值