可持久化线段树

原创 已于 2022-03-29 17:42:58 修改 · 770 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#可持久化线段树

于 2021-11-08 22:18:03 首次发布

在讲述可持久化线段树之前，大家需要先知道线段树是什么，如果还有不知道线段树的小伙伴可以看下我之前写的关于线段树的模板，在这附上博客地址：(63条消息) 线段树模板_AC__dream的博客-CSDN博客

我们知道线段树支持修改和查询操作，假如我们现在要对某个历史版本的线段树进行操作，我们应该如何达到目的呢？最简单粗暴的方法就是对于每一次修改操作，我们都将原来的线段树先复制一份，再在新建立的线段树上进行操作，这样我们就可以对之前的任何一个版本的线段树进行操作，但是这样显然是不可取的，无论是时间复杂度上还是空间复杂度上，这样做的代价都太高了。比如说我们要对第一个节点进行修改，则线段树上的哪些节点会发生改变呢？是不是叶子节点1到根节点连线上的所有节点会发生改变，而除了这些节点以外的其他节点都不会发生改变，那我们现在就应该想，能不能只创建一条支链并复用之前的线段树上的其他支链从而形成一棵新的线段树，我们只在新生成的那条链上进行操作，这样就会大大增加空间的利用率。

可持久化线段树随着操作会增加新的分支，所以我们没办法通过父节点乘以二得到子节点编号。这也是可持久化线段树与普通线段树的最大区别。

下面我就模板说一下详细的实现步骤。

注意下面的模板是不涉及到区间更新的，如果设计到区间更新则需要lazy标记。

建树：

void build(int id,int L,int R)
{
	l[id]=L;r[id]=R;sum[id]=0;
	if(L==R)
	{
		sum[id]=a[L];
		return ;
	}
	int mid=L+R>>1;
	//可持久化线段树的左右子节点无法通过乘2直接得到，每次都需要新开节点 
	ln[id]=++idx;rn[id]=++idx;
	build(ln[id],L,mid);
	build(rn[id],mid+1,R);
	pushup(id);
}

单点更新：

//pre代表旧版本的线段树，id代表当前版本的线段树
void update_point(int pre,int id,int pos,int val)
{
	//由旧版本对新版本进行赋值 
	rn[id]=rn[pre];ln[id]=ln[pre];l[id]=l[pre];r[id]=r[pre],sum[id]=sum[pre];
	if(l[id]==r[id])
	{
		sum[id]=val;
		return ;
	}
	int mid=l[id]+r[id]>>1;
    //如果需要更新的点位于左孩子上，我们就可以重用右孩子，新建左孩子
	if(pos<=mid) ln[id]=++idx,update_point(ln[pre],ln[id],pos,val);
    //如果需要更新的点位于右孩子上，我们就可以重用左孩子，新建右孩子
	else rn[id]=++idx,update_point(rn[pre],rn[id],pos,val);
	pushup(id);
}

单点询问：

//单点询问与普通线段树一样，我们只需要传入我们当前想要查询的线段树版本即可 
int query_point(int id,int x)
{
	if(l[id]==r[id]) return sum[id];
	int mid=l[id]+r[id]>>1;
	if(x<=mid) return query_point(ln[id],x);
	else return query_point(rn[id],x);
}

区间查询：

//我们要查询l~r上的线段树，我们就需要用r版本和l-1版本的线段树相减即可 
int query_interval(int pre,int id,int L,int R)
{
    //新旧版本线段树相减即可得到在l~r上进行操作的线段树
	if(l[id]>=L&&r[id]<=R) return sum[id]-sum[pre];
	int mid=l[id]+r[id]>>1;
	int ans=0;
	if(L<=mid) ans+=query_interval(ln[pre],ln[id],L,R);
	if(mid+1<=R) ans+=query_interval(rn[pre],rn[id],L,R);
	return ans;
}

下面给出两个模板题：

（单点修改+单点查询）题目链接：P3919 【模板】可持久化线段树 1（可持久化数组） - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;
const int M=1000010,N=3e7+10;
int l[N],r[N],ln[N],rn[N],a[M],root[M];
int sum[N],idx;
//可持久化线段树与普通线段树最大的不同就是普通线段树可以通过父节点乘二得到子节点 
void pushup(int id)
{
	sum[id]=sum[ln[id]]+sum[rn[id]];
}
void build(int id,int L,int R)
{
	l[id]=L;r[id]=R;sum[id]=0;
	if(L==R)
	{
		sum[id]=a[L];
		return ;
	}
	int mid=L+R>>1;
	//可持久化线段树的左右子节点无法通过乘2直接得到，每次都需要新开节点 
	ln[id]=++idx;rn[id]=++idx;
	build(ln[id],L,mid);
	build(rn[id],mid+1,R);
	pushup(id);
}
//pre代表旧版本的线段树，id代表当前版本的线段树
void update_point(int pre,int id,int pos,int val)
{
	//由旧版本对新版本进行赋值 
	rn[id]=rn[pre];ln[id]=ln[pre];l[id]=l[pre];r[id]=r[pre],sum[id]=sum[pre];
	if(l[id]==r[id])
	{
		sum[id]=val;
		return ;
	}
	int mid=l[id]+r[id]>>1;
	if(pos<=mid) ln[id]=++idx,update_point(ln[pre],ln[id],pos,val);
	else rn[id]=++idx,update_point(rn[pre],rn[id],pos,val);
	pushup(id);
}
//单点询问与普通线段树一样，我们只需要传入我们当前想要查询的线段树版本即可 
int query_point(int id,int x)
{
	if(l[id]==r[id]) return sum[id];
	int mid=l[id]+r[id]>>1;
	if(x<=mid) return query_point(ln[id],x);
	else return query_point(rn[id],x);
}
int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	root[0]=++idx;
	build(root[0],1,n);
	int t,op,loc,val;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d",&t,&op);
		if(op==1)
		{
			scanf("%d%d",&loc,&val);
			root[i]=++idx;
			update_point(root[t],root[i],loc,val);
		}
		else
		{
			scanf("%d",&loc);
			printf("%d\n",query_point(root[t],loc));
			root[i]=root[t];
		}
	}
	return 0;
}

（单点更新+区间查询）题目链接：P3834 【模板】可持久化线段树 2 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<queue>
#include<vector>
using namespace std;
const int N=2e7+10;
int a[N],l[N],r[N],sum[N],ln[N],rn[N],idx,root[N];
vector<int> alls;
void pushup(int id)
{
	sum[id]=sum[ln[id]]+sum[rn[id]];
} 
void build(int id,int L,int R)
{
	l[id]=L;r[id]=R;sum[id]=0;
	if(l[id]==r[id]) return ;
	int mid=L+R>>1;
	ln[id]=++idx;rn[id]=++idx;
	build(ln[id],L,mid);
	build(rn[id],mid+1,R);
	pushup(id);
}
void update_point(int pre,int id,int pos,int val)
{
	l[id]=l[pre];r[id]=r[pre];ln[id]=ln[pre];rn[id]=rn[pre];sum[id]=sum[pre];
	if(l[id]==r[id])
	{
		sum[id]+=val;
		return ;
	}
	int mid=l[id]+r[id]>>1;
	if(pos<=mid) ln[id]=++idx,update_point(ln[pre],ln[id],pos,val);
	else rn[id]=++idx,update_point(rn[pre],rn[id],pos,val);
	pushup(id);
	return ;
}
//我们要查询l~r上的线段树，我们就需要用r版本和l-1版本的线段树相减即可 
int query_interval(int pre,int id,int L,int R)
{
	if(l[id]>=L&&r[id]<=R) return sum[id]-sum[pre];
	int mid=l[id]+r[id]>>1;
	int ans=0;
	if(L<=mid) ans+=query_interval(ln[pre],ln[id],L,R);
	if(mid+1<=R) ans+=query_interval(rn[pre],rn[id],L,R);
	return ans;
}
int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		alls.push_back(a[i]);
	}
	sort(alls.begin(),alls.end());
	alls.erase(unique(alls.begin(),alls.end()),alls.end());
	for(int i=1;i<=n;i++) a[i]=lower_bound(alls.begin(),alls.end(),a[i])-alls.begin()+1;
	root[0]=++idx;
	build(root[0],1,alls.size());
	for(int i=1;i<=n;i++)
	{
		root[i]=++idx;
		update_point(root[i-1],root[i],a[i],1);
	}
	int lans,rans,k;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&lans,&rans,&k);
		int ll=0,rr=alls.size();
		while(ll<rr)
		{
			int mid=ll+rr+1>>1;
			if(query_interval(root[lans-1],root[rans],1,mid)<k) ll=mid;
			else rr=mid-1;
		}
		printf("%d\n",alls[ll]);
	}
	return 0;
}

下面给出主席树的两点说明：

第一个：如果一开始树是空的，我们并没有必要真的去建立一棵空树，我们直接从第一棵树开始建立即可，这样可以节省建树的空间和时间，这点还是有必要记住的

第二个：由于主席树对空间的要求比较严格，所以建议把当前区间的做右端点作为参数写入函数而不是直接新开l和r数组来单独存储区间的端点

第三个：主席树的空间一般开所给数据的20倍

第四个：为了方便找取主席树的版本，建议直接开一个root数组记录每一个版本线段树的根节点所对的编号

这篇博客中的可持久化线段树操作是不涉及到区间更新的，在之后的博客中我将会单独写一篇博客来介绍一下关于可持久化线段树中的区间修改。

11.1.5 蓝桥杯树形结构之线段树可持久化线段树(主席树)
tang7mj的博客
02-13 512
主席树是可持久化线段树的一种，得名于发明者Herbert S. Wilf教授的昵称"主席"。它通过保存每次操作后线段树的版本来实现持久化，使得我们能够访问和查询历史版本的数据。与传统线段树不同，主席树在更新时不会覆盖旧的节点，而是创建新的节点，从而保留了所有历史信息。主席树将线段树的强大功能与数据的持久化相结合，提供了一种解决动态数据问题的高效方法。通过主席树，我们不仅可以解决传统线段树能够处理的问题，还能查询到数据的历史状态，大大扩展了线段树的应用范围。
【日志】可持久化线段树
本居小铃的博客
02-28 168
可持久化线段树 前置知识：线段树 可持久化线段树建立在线段树的基础上，通过只保存部分被影响的结点，从而保存历史版本线段树。 因此祖传线段树的类似堆一样的存储方式是不能动态存入新的点的，需要动态开点。 大致过程 对于可持久化线段树，需要的也就是： 动态开点 其实就是事先开个大数组，然后找个变量增加结点即可。 连接旧结点 可以发现每次修改影响的结点就那几个。所以，可以对这些受影响的结点另开个结点，然后连接（比如右儿子+1的话，那么新开个结点，记录右儿子+1的结果，同理这个结点的信息也需要被记录，不过左儿
权值线段树与可持久化线段树
诗鸩的博客
08-20 451
权值线段树 是什么 权值线段树也是一棵线段树，但是它与普通线段树有所区别： 普通线段树记录的是一段区间 [l，r] 中的a[l]~a[r]的某种信息（如sum，max，最大连续子段和等），其叶子节点为a[i]。 权值线段树记录的是区间l~r每个数字出现的次数和，其叶子节点为 i 在数组a中出现的次数。 做什么 简单来看，权值线段树可以非常方便地查询一段区间的数字出现的次数。 引申出它...
可持久化线段树详解
qq_50097696的博客
09-28 185
每次修改时，只新建被影响的链，其余部分共用上一版本的
【算法笔记】AC自动机+可持久化线段树解决大字符集的问题
执子之手,与子偕老
02-08 739
问题： 这里的trie树和普通的不一样，因为串长最多有O(n^2),而不是以前的O(n)。姑且把它叫做广义Trie树 这道题目显然是裸的AC自动机，然而字符集很大。 这里不能直接map，用一般的均摊AC自动机（求fail的时候用while跳）。这样复杂度错误的 要用可持久化线段树维护trans数组 下面的代码只是一个思路。以前写这道题的代码找不到了，，， void build(){ hh...
可持久化线段树的空间
最新发布
08-04
可持久化线段树是一种支持历史版本查询的数据结构，其核心思想是在每次修改操作时保留完整的旧版本信息。这使得它在某些应用场景中非常有用，例如版本控制系统或需要回溯操作的算法问题。 ### 空间复杂度分析 可持久化线段树的空间复杂度与普通线段树相比有所增加。普通线段树的空间复杂度为 $O(n)$，其中 $n$ 是数据规模。而可持久化线段树由于需要保留历史版本，每次更新操作都会生成新的节点，因此其空间复杂度为 $O(n \log n)$。具体来说，每次更新操作最多会生成 $O(\log n)$ 个新节点，因为线段树的高度为 $O(\log n)$，每个节点最多分裂一次[^1]。 ### 实现原理 可持久化线段树的核心实现原理是**节点复用**和**路径复制**。当对线段树进行更新时，只有从根节点到目标节点的路径上的节点会被复制，其余节点保持不变。这种方式避免了对整个线段树的完全复制，从而节省了内存[^1]。 具体实现中，每个版本的线段树通过一个根节点指针来标识。当进行更新操作时，新版本的根节点指向一个新的节点，而未修改的子树则继续指向旧版本的节点。这种设计使得不同版本之间可以共享未修改的部分，从而减少内存开销。 以下是一个简单的可持久化线段树的实现示例，用于单点更新和区间查询： ```cpp #include <iostream> #include <vector> using namespace std; struct Node { int val; // 节点值，例如区间和 Node* left; Node* right; Node(int v) : val(v), left(nullptr), right(nullptr) {} }; class PersistentSegmentTree { private: vector<int> data; Node* build(Node* node, int l, int r) { if (l == r) { node->val = data[l]; return node; } int mid = (l + r) / 2; node->left = new Node(0); node->right = new Node(0); build(node->left, l, mid); build(node->right, mid + 1, r); node->val = node->left->val + node->right->val; return node; } Node* update(Node* node, int l, int r, int idx, int value) { if (l == r) { Node* new_node = new Node(value); return new_node; } int mid = (l + r) / 2; Node* new_node = new Node(0); if (idx <= mid) { new_node->left = update(node->left, l, mid, idx, value); new_node->right = node->right; } else { new_node->left = node->left; new_node->right = update(node->right, mid + 1, r, idx, value); } new_node->val = new_node->left->val + new_node->right->val; return new_node; } int query(Node* node, int l, int r, int ql, int qr) { if (qr < l || ql > r) return 0; if (ql <= l && r <= qr) return node->val; int mid = (l + r) / 2; return query(node->left, l, mid, ql, qr) + query(node->right, mid + 1, r, ql, qr); } public: vector<Node*> roots; // 存储每个版本的根节点 PersistentSegmentTree(vector<int>& arr) { data = arr; roots.push_back(new Node(0)); build(roots[0], 0, data.size() - 1); } void update(int version, int idx, int value) { Node* new_root = update(roots[version], 0, data.size() - 1, idx, value); roots.push_back(new_root); } int query(int version, int ql, int qr) { return query(roots[version], 0, data.size() - 1, ql, qr); } }; ``` ### 内存占用分析 可持久化线段树的内存占用主要由以下几个部分构成： 1. **节点存储**：每个节点需要存储值、左右子节点指针。通常每个节点的大小为常数级别（例如包含一个整数值和两个指针）。 2. **版本管理**：每个版本通过一个根节点指针进行管理，根节点指针的存储开销为 $O(1)$。 3. **路径复制**：每次更新操作会生成新的节点，这些新节点的总数为 $O(\log n)$，因此总内存占用为 $O(n \log n)$。 在实际应用中，内存占用还可能受到编程语言的内存管理机制影响。例如，在 C++ 中手动管理内存可能导致较高的内存碎片，而在 Java 或 Python 等具有垃圾回收机制的语言中，内存占用可能相对较低，但具体表现取决于实现细节。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值