树链剖分之HLD

已于 2022-02-06 22:19:39 修改
阅读量2.2k 收藏
点赞数 1
分类专栏： ACM/ICPC ACM数据结构 文章标签： 树链剖分 HLD 轻重边剖分 hdu3966 ACM
于 2017-01-02 13:51:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012061345/article/details/53976222
版权

树链剖分之HLD

树链剖分的原理

对于数组这样的线性结构，要在其上实现区间查询（和与最值）、区间修改甚至是区间增删都是有办法的。例如Sparse Table算法、树状数组、线段树以及伸展树等。而树是一种非线性结构，为了高效的实现在树上的路径查询、路径修改操作，基本做法是将树按照某种方式剖成若干条链，再将这些链按照顺序组成数组，最后在数组上采用线段树等手段实现操作。考虑如下一棵树：

在这里插入图片描述

可以把它剖成6条链，分别是 A C H L N ACHLN ACHLN、 G G G、 I M IM IM、 B F K BFK BFK、 E E E和 D J DJ DJ，因此对应的新数组是

在这里插入图片描述

轻重边剖分

轻重边剖分（Heavy-light Decomposition）是树链剖分常用的一种方法，上面的例子就是一个HLD的例子。HLD可以用来解决一大类问题：在树的结构形态不发生变化的前提下，实现路径操作和子树操作（修改、查询和及最值）。

重儿子：某个节点的子节点，其子树节点数量最大，则该子节点为该节点的重儿子。其余为轻儿子。在上例中， C C C是 A A A的重儿子， H H H是 C C C的重儿子， F F F是 B B B的重儿子。

重边：父节点和重儿子之间的边称为重边。在上例中， A C AC AC、 C H CH CH、 B F BF BF都是重边。对应的，父节点和轻儿子的边就称为轻边。

重链：全部由重边构成的路径称为重链，又称为重路径。在上例中， A C H L N ACHLN ACHLN、 G G G、 I M IM IM、 B F K BFK BFK、 E E E和 D J DJ DJ就是重链。

N N N个节点的树的任意一条路径上，最多只有 l o g N logN logN条重链。每一条重链就是对应数组的一个连续的部分，因此其上的操作最多为 l o g N logN logN。因此每次树上操作的时间为 l o g 2 N log^2N log2N。

考虑每一次路径操作，我们需要知道路径到底是由哪些重链组成的以及这些重链在数组中对应的部分。路径上的重链信息显然是可以求出的，但是不必专门求出，在操作中不停更新重链即可。为了更新重链信息，对于每个节点还需记录深度信息 d e p t h depth depth以及每个节点所在重链的最顶层节点 t o p top top。深度信息比较容易理解。 t o p top top信息实际上就是每条链的第一个节点，例如在上例中 H H H的 t o p top top就是 A A A， L L L的 t o p top top也是 A A A，而 K K K的 t o p top top则是 B B B。

有了 d e p t h depth depth和 t o p top top信息，即可进行路径操作。考虑 K M KM KM之间的路径操作。因为 K K K和 M M M的 t o p top top不同，所以可以肯定 K M KM KM不是一条重链。又因为 M M M的 t o p top top深度更深，所以可以肯定 M M M及其 t o p top top之间的重链全部都在路径上，可以进行一次区间操作；该次操作完成以后就跳到节点 C C C，因为节点 C C C是 M M M的 t o p top top的父节点。再次考虑 K C KC KC，因为 K K K的 t o p top top深度更深，所以 B K BK BK全部在路径上，进行一次区间操作；然后跳到 A A A。 A A A、 C C C的 t o p top top相同，说明 A C AC AC是最后一段区间，对其进行操作即可。

因为轻重边的区别完全取决于子树的节点数量，每个节点设置一个 s i z e size size域，在一次深搜中就能确定 s i z e size size的值，同时可以确定每个节点的重儿子，以及每个节点的 d e p t h depth depth信息与父节点。确定重儿子以后，再一次深搜就可以确定重链的顺序以及每个节点的 t o p top top。此次深搜的顺序即转化后的数组的索引序号，然后对该数组建树状数组或者线段树并进行操作即可。因此，整个解法复杂度为 O ( N + Q l o g — — 2 N ) O(N+Qlog——2N) O(N+Qlog——2N)。其中 Q Q Q为操作的总数量。

实现

hdu3966是一个典型的树链剖分题目，树的形态维持不变，路径更新、单点查询，剖分完以后使用带延迟的线段树即可。

//#pragma comment(linker, "/STACK:1024000000,1024000000") 
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

#define SIZE 50010

struct edge_t{
	int node;//另一个节点的编号
	int next;//下一条边的地址，实际地址为Edge+next
}Edge[SIZE<<1];
int ECnt = 0;
int Vertex[SIZE];//邻接表表示所有的边

//a、b之间建立两条无向边
void mkEdge(int a,int b){
	Edge[ECnt].node = b;
	Edge[ECnt].next = Vertex[a];
	Vertex[a] = ECnt ++;

	Edge[ECnt].node = a;
	Edge[ECnt].next = Vertex[b];
	Vertex[b] = ECnt ++;
}

struct node_t{
    int parent;   //父节点
	int heavy_son;//重边的子节点
	int depth;     //深度
	int size;     //size域
	int top;      //本节点所在的重链的最顶层节点
	int nid;      //在dfs重链时重新对节点编号，确保同一条链上的节点相邻
    int weight;   //权值,本题中即所求的数量
}Node[SIZE];
int TIdx = 0;
int NewIdx[SIZE];//新编号到原树节点的映射
int N,M,P;

//dfs找出所有重边，t为节点，parent为其父节点，depth为深度
//该dfs实际上确立了树的结构
void dfsHeavyEdge(int t,int parent,int depth){
	Node[t].depth = depth;
	Node[t].parent = parent;
	Node[t].size = 1;
	//对t的所有子节点
	for(int next=Vertex[t];next;next=Edge[next].next){
		int u = Edge[next].node;
		if ( u == parent ) continue;
		dfsHeavyEdge(u,t,depth+1);
		Node[t].size += Node[u].size;
		//判断重边
		if ( Node[u].size > Node[Node[t].heavy_son].size )
			Node[t].heavy_son = u;
	}
}

//dfs找出所有重链,t为节点，top为当前节点所在重链的最顶层节点
//重链实际上是以其顶层节点为标识保存的，任意节点都能够直接得出其所在重链的顶层节点
void dfsHeavyPath(int t,int top){
	Node[t].top = top;
	Node[t].nid = TIdx++;
	NewIdx[Node[t].nid] = t;

	//t没有重儿子，实际上就是叶节点
	if ( 0 == Node[t].heavy_son ) return;
	dfsHeavyPath(Node[t].heavy_son,top);

	//对t的所有节点
	for(int next=Vertex[t];next;next=Edge[next].next){
		int u = Edge[next].node;
		if ( u == Node[t].parent 
			|| u == Node[t].heavy_son ) continue;
		
		dfsHeavyPath(u,u);
	}
}

//带延迟的求区间和的线段树
struct stnode_t{
	int peak;
	int delay;
}ST[SIZE<<2];

inline int lson(int t){return t<<1;}
inline int rson(int t){return (t<<1)|1;}

void _pushUp(int t){ST[t].peak=ST[lson(t)].peak+ST[rson(t)].peak;}
void _pushDown(int t){
	if ( 0 == ST[t].delay ) return;
	
	ST[lson(t)].delay += ST[t].delay;
	ST[lson(t)].peak += ST[t].delay;
	ST[rson(t)].delay += ST[t].delay;
	ST[rson(t)].peak += ST[t].delay;
	ST[t].delay = 0;
}

//建树，递归建立节点
void build(int t,int s,int e){
	ST[t].delay = 0;

	if ( s == e ){
		ST[t].peak = Node[NewIdx[s]].weight;
		return;
	}
	int mid = ( s + e ) >> 1;
	build(lson(t),s,mid);
	build(rson(t),mid+1,e);
	_pushUp(t);
}
//[a,b]区间增加delta
void modify(int t,int s,int e,int a,int b,int delta){
	if ( a <= s && e <= b ){
		ST[t].delay += delta;
		ST[t].peak += delta;
		return;
	}

	_pushDown(t);
	int mid = ( s + e ) >> 1;
	if ( a <= mid ) modify(lson(t),s,mid,a,b,delta);
	if ( mid < b ) modify(rson(t),mid+1,e,a,b,delta);
	_pushUp(t);
}
//单点查询
int query(int t,int s,int e,int idx){
	if ( s == e ) return ST[t].peak;
	_pushDown(t);
	int mid = ( s + e ) >> 1;
	int ret = ( idx <= mid ) 
		? query(lson(t),s,mid,idx)
		: query(rson(t),mid+1,e,idx);
	_pushUp(t);
	return ret;
}

//关键操作，将原树上(x,y)路径的所有节点权值增加val
void change(int x,int y,int val){
	//当x,y不处于同一条重链
	while( Node[x].top != Node[y].top ){
		//令x所处的重链总是更深
		if ( Node[Node[x].top].depth < Node[Node[y].top].depth )
			swap(x,y);
		//将x所在的链的链顶到x的区间进行修改
		modify(1,1,N,Node[Node[x].top].nid,Node[x].nid,val);
		//将x修改为原链顶的父亲，实质上就是跳到了另外一条链
		x = Node[Node[x].top].parent;
	}
	//到此处时，x、y处于同一条链，令x总是更浅，此举是为了确定左右区间
	if ( Node[x].depth > Node[y].depth ) swap(x,y);
	//将x、y之间的路径更新
	modify(1,1,N,Node[x].nid,Node[y].nid,val);
}
inline void init(){
	ECnt = TIdx = 1;
	fill(Vertex,Vertex+N+1,0);
	for(int i=0;i<=N;++i)Node[i].heavy_son = 0;
}
bool read(){
	if ( EOF == scanf("%d%d%d",&N,&M,&P) )
		return false;

	init();
	for(int i=1;i<=N;++i)scanf("%d",&Node[i].weight);
	for(int i=0;i<M;++i){
		int a,b;
		scanf("%d%d",&a,&b);
		mkEdge(a,b);
	}
	//以第1个节点为根建树
	dfsHeavyEdge(1,0,0);
	//从根节点开始递归建重链
	dfsHeavyPath(1,1);
	//以ST[1]为根节点区间[1,N]建线段树
	build(1,1,N);
	return true;
}
char Cmd[5];
int main(){
	while( read() ){
		while(P--){
			scanf("%s",Cmd);
			if ( 'Q' == *Cmd ){
				int x;
				scanf("%d",&x);
				printf("%d\n",query(1,1,N,Node[x].nid));
			}else{
				int x,y,v;
				scanf("%d%d%d",&x,&y,&v);
				if ( 'D' == *Cmd ) v = -v;
				change(x,y,v);
			}
		}
	}
	return 0;
}
罗博士
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NOIP 树链剖分 NOIP 树链剖分
10-30
NOIP 树链剖分 NOIP 树链剖分
树链剖分算法.pptx
09-03
树链剖分，计算机术语，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链
树链剖分模板题
05-19
#include <cstdio> #include <iostream> #include <vector> #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]; void dfs1(int x){ siz[x]=1; int sz=to[x].size(); for(int i=0;i<sz;++i){ int y=to[x][i]; if(y==f[x][0])continue; f[y][0]=x; dep[y]=dep[x]+1; dfs1(y); siz[x]+=siz[y]; if(siz[y]>siz[son[x]])son[x]=y; } } void dfs2(int x,int root){ top[x]=root; pos[x]=++tot; if(son[x])dfs2(son[x],root); int sz=to[x].size(); for(int i=0;i<sz;++i){ int y=to[x][i]; if(y==f[x][0] || y==son[x])continue; dfs2(y,y); } } void update(int k,int l,int r,int P,int V){ if(l==r){ Max[k]=Sum[k]=V; return; } int mid=(l+r)>>1; if(P<=mid)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)x=f[x][i]; } int lca(int x,int y){ if(dep[x]>dep[y])up(x,dep[y]); if(dep[x]<dep[y])up(y,dep[x]); if(x==y)return x; for(int i=15;i>=0;--i) if(f[x][i]!=f[y][i])x=f[x][i],y=f[y][i]; return f[x][0]; } int getm(int k,int l,int r,int L,int R){ if(L<=l && r<=R)return Max[k]; int res=-INF,mid=(l+r)>>1; if(L<=mid)res=max(res,getm(k*2,l,mid,L,R)); if(R>mid)res=max(res,getm(k*2+1,mid+1,r,L,R)); return res; } int gets(int k,int l,int r,int L,int R){ if(L<=l && r<=R)return Sum[k]; int res=0,mid=(l+r)>>1; if(L<=mid)res+=gets(k*2,l,mid,L,R); if(R>mid)res+=gets(k*2+1,mid+1,r,L,R); return res; } int main(){ scanf("%d",&n); for(int i=1,a,b;i<n;++i){ scanf("%d%d",&a,&b); to[a].push_back(b); to[b].push_back(a); } dep[1]=1; dfs1(1); dfs2(1,1); for(int i=1;i<=15;++i) for(int j=1;j<=n;++j)f[j][i]=f[f[j][i-1]][i-1]; for(int i=1;i<=n;++i){ scanf("%d",&w[i]); update(1,1,n,pos[i],w[i]); } int q; scanf("%d",&q); while(q--){ char s[10]; int u,v,t; scanf("%s",s); if(s[1]=='H'){ scanf("%d%d",&u,&t); w[u]=t; update(1,1,n,pos[u],t); } if(s[1]=='M'){ scanf("%d%d",&u,&v); int ans=-INF,t=lca(u,v); for(int i=u;i;i=f[top[i]][0]) if(dep[t]<dep[top[i]]) ans=max(ans,getm(1,1,n,pos[top[i]],pos[i])); else{ ans=max(ans,getm(1,1,n,pos[t],pos[i])); break; } for(int i=v;i;i=f[top[i]][0]) if(dep[t]<dep[top[i]]) ans=max(ans,getm(1,1,n,pos[top[i]],pos[i])); else{ ans=max(ans,getm(1,1,n,pos[t],pos[i])); break; } printf("%d\n",ans); } if(s[1]=='S'){ scanf("%d%d",&u,&v); int ans=0,t=lca(u,v); for(int i=u;i;i=f[top[i]][0]) if(dep[t]<dep[top[i]]) ans+=gets(1,1,n,pos[top[i]],pos[i]); else{ ans+=gets(1,1,n,pos[t],pos[i]); break; } for(int i=v;i;i=f[top[i]][0]) if(dep[t]<dep[top[i]]) ans+=gets(1,1,n,pos[top[i]],pos[i]); else{ ans+=gets(1,1,n,pos[t],pos[i]); break; } printf("%d\n",ans-w[t]); } } }
负载均衡器在系统设计中的作用
小技术君
08-29 62
当一个网站变得非常流行时，网站上的流量增加，单个服务器的负载也增加。并发流量超过单个服务器的处理能力，导致网站变得对用户响应缓慢。为了应对这些高数据量的请求，以快速可靠的方式返回正确的响应，我们需要对服务器进行扩展。这可以通过向网络中添加更多的服务器，并将所有请求分布到这些服务器上来实现。但是...谁来决定将哪个请求路由到哪个服务器呢...???Load-Balancer-System-Desig...
测试基础知识点第一期分享
m0_57370705的博客
07-20 253
α测试与β测试 alpha测试Beta测试都需要用户参加。但是，alpha测试是用户在开发环境或者是公司内部模拟实际操作环境的测试。Beta是由最终用户来测试。 区别：两者的主要区别是测试的场所不同。Alpha测试是指把用户请到开发方的场所来测试，beta测试是指在一个或多个用户的场所进行的测试。 Alpha测试的环境是受开发方控制的，用户的数量相对比较少，时间比较集中。而beta测试的环境是不受开发方控制的，谁也不知道用户如何折磨软件，用户数量相对比较多，时间不集中。一般地，alpha测试先于beta测试
hdl 简单设计举例
maclinuxye的博客
01-23 663
电路设计举例        本节设计一个简化的处理器取指令，体会HDL的使用：        处理器一般有一个PC寄存器，其中存储指令地址，本次尝试包括两个部分：PC模块，指令存储器。 1、 PC模块的设计与实现 PC模块的功能就是给出取指令地址，同时每个时钟周期取指令地址递增。   1、 rst 宽度为1 输入 作用为复位信号 2、 clk 宽度为1 输入 作用为时钟信号 3、
【数据结构】树链剖分
Video_game的博客
12-11 1028
树链剖分
树链剖分
andyc_03的博客
04-17 1629
【算法介绍】 树链剖分就是将树分割成多条链，然后利用数据结构（线段树、树状数组等）来维护这些链。 当树的形态不发生改变的时候，我们可以先对其进行链的剖分，每条链就相当于一个序列，操作就可以被拆分成几条完整的链来解决，然后利用一些数据结构加以维护即可。 我们希望通过这样的方式，来达到一些树上修改、计算的目的 【算法流程】 轻重链剖分 概念引入：把一个节点u的所有儿子中size[v]最大的一个作为重儿子，则称(u,v)为重边，u到其余的儿子v'的边(u,v')为轻边。 性质：(u,v)为轻边.
树链剖分（重链剖分）
weixin_55851276的博客
07-07 451
一.什么是树链剖分       树剖是通过某些特殊的划分方法，将树上的节点划分到 不同 的链中，并且保证同一条链上的各个节点的 dfs序 连续，这样就可以用 线段树 对每一条链进行维护。从而方便解决 树上单条路径的查询和修改 问题。需注意：在使用树剖时树的形态不可以变化，只能改变路径上节点的信息 。树剖的核心在于 通过特殊的 划分方式 将 树上路径问题 转化为 区间 问题      树剖一般解决的问题： 树
第5章 树链剖分 测试数据.rar
12-02
http://ybt.ssoier.cn:8088 信息学奥赛一本通(提高篇)测试数据\第4部分 数据结构(提高篇)\ 第5章 树链剖分 测试数据
自然语言处理中的文本比较：算法与应用
最新发布
禅与计算机程序设计艺术
01-08 876
1.背景介绍 自然语言处理(NLP)是人工智能(AI)领域的一个重要分支，其主要目标是让计算机理解、生成和处理人类语言。文本比较是NLP中一个基本 yet 重要的任务，它广泛应用于文本摘要、文本检索、文本相似度计算、文本聚类等方面。在本文中，我们将深入探讨文本比较的核心概念、算法原理、实现细节以及未来发展趋势。 2.核心概念与联系 在自然语言处理中，文本比较是将两个或多个文本序列进行比较，以...
各种HDR标准的技术细节，读这一篇就够了
q274488181的博客
03-09 1万+
笔者按：最近要做算法层面的HDR/SDR互相转换相关的内容，但是对HDR相关的内容真的没有一个很全面的认识。HDR转SDR还好，都是0~255的8bit图像；但是如果SDR转HDR，转换出来的图像在不同的显示器上观感差距巨大。所以就对这个东西比较迷惑。这篇图像就尝试来弄清楚，这些HDR标准，在技术细节上都是怎么样的，包含哪些内容，有哪些区别。此外，对于一些共性的知识，这里也会给出讲解。
HDLBits（0）简介&如何使用
weixin_51944426的博客
09-12 4617
ASD
软件测试的术语SRS，HLD，LLD，BD，FD，DD
lshdp的博客
04-16 5857
SRS：软件需求说明书，是指在研究用户要求的基础上，完成可行性分析和投资效益分析以后，由软件工程师或分析员编写的说明书。 HLD：概要设计说明书，编制的目的是说明对程序系统的设计考虑，包括程序系统的基本处理流程、程序系统的组织结构、模块划分、功能分配、接口设计、运行设计、安全设计、数据结e799bee5baa6e997aee7ad94e4b893e5b19e31333431373333构设计和出...
php负载均衡原理_阿里P8架构师谈：负载均衡的原理、分类、实现架构，使用场景...
weixin_35261385的博客
12-15 141
头条不允许放外链, 关注我私信 [资料], 送你整理好的 100 本 pdf资料, 如图很多人在日常生活中使用不同的Web服务，他们也从这些服务中获得快速响应。但是，大多数用户并不了解负责通过Internet传递内容的过程的规模。他们没有意识到在后台扩展系统所需的漫长过程。这个漫长的过程涉及到当成千上万的用户同时在网站上发出请求时，跨多个服务器分配请求。当网站变得非常流行时，该网站上的流量会增加，...
算法自学——树链剖分
MaTF_的博客
08-05 471
树链剖分就是将一棵树划分成若干条链。
旋转体的体积和表面积
热门推荐
RBS的专栏
09-18 3万+
积分公式 令曲线y=f(x)y=f(x)绕xx轴旋转，形成的旋转体，则其体积和表面积可以计算积分而得（假设体积和表面积一定存在，积分一定存在，这里不讨论数学问题）。 体积公式为： V=∫πy2dxV={\int}{\pi}{y^2}dx 表面积公式为 S=∫2πy1+y′2−−−−−−√dxS=\int{2\pi}{y}\sqrt{1+{y^{\prime}}^2}dx 剩下的就是推导
Aragorn 树链剖分
09-24
Aragorn 树链剖分是一种将一棵树剖分为若干条链的算法，然后利用数据结构去维护每一条链的技术。剖分完毕后，每条重链相当于一段区间，然后可以使用数据结构去维护整个树。具体过程是通过两次深度优先搜索来实现的：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值