当前位置: 首页 > news >正文

AcWing 2568:树链剖分 ← 线段树+DFS

【题目来源】
https://www.acwing.com/problem/content/2570/

【题目描述】
给定一棵树,树中包含 n 个节点(编号 1∼n),其中第 i 个节点的权值为 ai。
初始时,1 号节点为树的根节点。
现在要对该树进行 m 次操作,操作分为以下 4 种类型:
● 1 u v k,修改路径上节点权值,将节点 u 和节点 v 之间路径上的所有节点(包括这两个节点)的权值增加 k。
● 2 u k,修改子树上节点权值,将以节点 u 为根的子树上的所有节点的权值增加 k。
● 3 u v,询问路径,询问节点 u 和节点 v 之间路径上的所有节点(包括这两个节点)的权值和。
● 4 u,询问子树,询问以节点 u 为根的子树上的所有节点的权值和。

【输入格式】
第一行包含一个整数 n,表示节点个数。
第二行包含 n 个整数,其中第 i 个整数表示 ai。
接下来 n−1 行,每行包含两个整数 x,y,表示节点 x 和节点 y 之间存在一条边。
再一行包含一个整数 m,表示操作次数。
接下来 m 行,每行包含一个操作,格式如题目所述。

【输出格式】
对于每个操作 3 和操作 4,输出一行一个整数表示答案。

【数据范围】
1≤n,m≤10^5,
0≤ai,k≤10^5,
1≤u,v,x,y≤n

【输入样例】
5
1 3 7 4 5
1 3
1 4
1 5
2 3
5
1 3 4 3
3 5 4
1 3 5 10
2 3 5
4 1

【输出样例】
16
69

【算法分析】
● 树链剖分
(1)树链剖分的核心思想,就是将树中任意一条路径拆分成 O(log_2 n) 段的
连续区间(或重链)。拆分后,树的所有操作都可转化为区间操作,且通常采用线段树进行维护。
(2)树链剖分的几个概念

重儿子/轻儿子:结点个数最多的子树的根结点称为当前结点的重儿子,其他子结点称为当前结点的轻儿子。若当前结点存在多个结点个数相同的子树,则任选一个子树的根结点作为当前结点的重儿子。故易知每个结点的重儿子是唯一的
重边/轻边:重儿子与父结点之间的边,称为重边。其他边称为轻边
重链:重边构成的极大路径,称为重链。
DFS序:深度优先遍历树的重儿子,可保证树中各条重链结点的编号是连续的。此性质保证了树链剖分后各区间是连续的。
(3)将一条路径拆分为重链的过程,类似于求最近公共祖先(LCA)。

【算法代码】

#include <bits/stdc++.h>
using namespace std;typedef long long LL;const int maxn=1e5+5;
const int maxm=maxn<<1;
int val[maxn],e[maxm],ne[maxm],h[maxn],idx;//id[]:dfn sequence number of the node
//nv[]:point weight of each dfs sequence number
int id[maxn],nv[maxn],tot;//cnt[]:number of child nodes, top[]:vertex of heavy chain
//son[]:heavy son, fa[]:parent node
int dep[maxn],cnt[maxn],top[maxn],fa[maxn],son[maxn];int n,m;struct SegmentTree {int le,ri;LL sum,lazy;
} tr[maxn<<2];void add(int a,int b) {e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}void dfs1(int u,int father,int depth) { //dfs1:pretreatmentdep[u]=depth,fa[u]=father,cnt[u]=1;for(int i=h[u]; i!=-1; i=ne[i]) {int j=e[i];if(j==father) continue;dfs1(j,u,depth+1);cnt[u]+=cnt[j];if(cnt[son[u]]<cnt[j]) son[u]=j; //heavy son}
}void dfs2(int u,int vx) { //dfs2:split, t:vertex of heavy chainid[u]=++tot,nv[tot]=val[u],top[u]=vx;if(!son[u]) return; //leaf nodedfs2(son[u], vx); //Heavy son's heavy chain splitfor(int i=h[u]; i!=-1; i=ne[i]) { //handle light sonint j=e[i];if(j==fa[u] || j==son[u]) continue;dfs2(j,j); //The vertex of the light son's heavy chain is himself}
}/*------------ Content of segment tree ------------*/void pushup(int u) {tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;
}void pushdown(int u) {auto &rt=tr[u], &L=tr[u<<1], &R=tr[u<<1|1];if(rt.lazy) {L.sum+=rt.lazy*(L.ri-L.le+1);L.lazy+=rt.lazy;R.sum+=rt.lazy*(R.ri-R.le+1);R.lazy+=rt.lazy;rt.lazy=0;}
}void build(int u,int le,int ri) {tr[u]= {le,ri,nv[ri],0};if(le==ri) return;int mid=le+ri>>1;build(u<<1,le,mid), build(u<<1|1,mid+1,ri);pushup(u);
}void update(int u,int le,int ri,int k) {if(le<=tr[u].le && ri>=tr[u].ri) {tr[u].lazy+=k;tr[u].sum+=k*(tr[u].ri-tr[u].le+1);return;}pushdown(u);int mid=tr[u].le+tr[u].ri>>1;if(le<=mid) update(u<<1,le,ri,k);if(ri>mid) update(u<<1|1,le,ri,k);pushup(u);
}LL query(int u,int le,int ri) {if(le<=tr[u].le && ri>=tr[u].ri) return tr[u].sum;pushdown(u);int mid=(tr[u].le+tr[u].ri)>>1;LL res=0;if(le<=mid) res+=query(u<<1,le,ri);if(ri>mid) res+=query(u<<1|1,le,ri);return res;
}void update_path(int u,int v,int k) {while(top[u]!=top[v]) { //Climb up to find the same heavy chainif(dep[top[u]]<dep[top[v]]) swap(u,v);//Because of dfs order, the id of the upper node//must be smaller than that of the lower nodeupdate(1,id[top[u]],id[u],k);u=fa[top[u]];}if(dep[u]<dep[v]) swap(u,v);//In the same heavy chain, the remaining intervals are processedupdate(1,id[v],id[u],k);
}LL query_path(int u,int v) {LL res=0;while(top[u]!=top[v]) { //Climb up to find the same heavy chainif(dep[top[u]]<dep[top[v]]) swap(u,v);res+=query(1,id[top[u]],id[u]);u=fa[top[u]];}if(dep[u]<dep[v]) swap(u,v);//In the same heavy chain, the remaining intervals are processedres+=query(1,id[v],id[u]);return res;
}void update_tree(int u,int k) { //Add k to all the subtrees//Because of the order of dfs, the interval can be found directly//by the number of subtree nodesupdate(1,id[u],id[u]+cnt[u]-1,k);
}LL query_tree(int u) {//Because of the order of dfs, the interval can be found directly//by the number of subtree nodesreturn query(1,id[u],id[u]+cnt[u]-1);
}int main() {scanf("%d",&n);memset(h,-1,sizeof h);for(int i=1; i<=n; i++) scanf("%d",&val[i]);for(int i=1; i<n; i++) {int a,b;scanf("%d %d",&a,&b);add(a,b),add(b,a);}dfs1(1,-1,1);dfs2(1,1);build(1,1,n);scanf("%d",&m);while(m--) {int op,u,v,k;scanf("%d%d",&op,&u);if(op==1) {scanf("%d%d",&v,&k);update_path(u,v,k);} else if(op==2) {scanf("%d",&k);update_tree(u,k);} else if(op==3) {scanf("%d",&v);printf("%lld\n",query_path(u,v));} else printf("%lld\n",query_tree(u));}return 0;
}/*
in:
5
1 3 7 4 5
1 3
1 4
1 5
2 3
5
1 3 4 3
3 5 4
1 3 5 10
2 3 5
4 1out:
16
69
*/




【参考文献】
https://www.acwing.com/solution/content/62664/
https://www.acwing.com/problem/content/video/2570/
https://blog.csdn.net/qq_46105170/article/details/125497358








 

http://www.lryc.cn/news/356268.html

相关文章:

  • PCIe协议之-DLLP详解
  • Jmeter+prometheus+grafana性能测试
  • Hololens 2 新建自定义按钮
  • 景源畅信:抖音小店新手小白如何做好运营?
  • 力扣 42. 接雨水 python AC
  • The 2022 ICPC Asia Nanjing Regional Contest - External D
  • 2024年蓝桥杯B组C++——复盘
  • 微调Llama3实现在线搜索引擎和RAG检索增强生成功能
  • 【软件工程】【23.04】p1
  • Flutter 中的 ColoredBox 小部件:全面指南
  • 【LeetCode 随笔】面试经典 150 题【中等+困难】持续更新中。。。
  • SwiftUI中AppStorage的介绍使用
  • iCloud 照片到 Android 指南:帮助您快速将照片从 iCloud 传输到安卓手机
  • 知识点总结
  • Python并发与异步编程
  • 动态内存管理—C语言通讯录
  • 美光EMMC芯片丝印型号查询 8LK17/D9PSK, OXA17/JY997
  • win32-鼠标消息、键盘消息、计时器消息、菜单资源
  • springboot项目部署到linux服务器
  • MagicLens:新一代图像搜索技术和产品形态
  • [9] CUDA性能测量与错误处理
  • Java学习四
  • Vue 父组件使用refs来直接访问和修改子组件的属性或调用子组件的方法
  • 范罗士、希喂、安德迈爆款宠物空气净化器哪款好?深度对比测评
  • SAP OBYC自动记账 详解
  • 《NoSQL数据库技术与应用》 MongoDB副本集
  • Flutter 中的 DropdownButtonFormField 小部件:全面指南
  • 哈希算法教程(个人总结版)
  • Nocobase快速上手 -第一个collection
  • 吴恩达2022机器学习专项课程C2W2:2.19 sigmoid函数的替代方案 2.20如何选择激活函数 2.21 激活函数的重要性