【主席树】P3919 【模板】可持久化线段树 1(可持久化数组)

本文介绍了一种基于线段树的数据结构实现方法,通过创建并更新多个版本的树来处理区间更新和查询操作,特别适用于需要频繁更新和查询的场景。文章详细描述了线段树的构建、更新和查询过程,并提供了完整的代码实现。

基本模板,就是每次修改再建立一个根节点,然后将要修改的部分建立新节点;之后每次询问就从提问的那个root去进行线段树上的查找即可

 

代码

#include<bits/stdc++.h>
using namespace std;
const int maxn=4e7+5;
const int maxm=1e6+5;
int n,m,cnt,root[maxn],a[maxm];
struct tree
{
	int l,r,val;
}tr[maxn];
int build(int now,int l,int r)
{
	now=++cnt;
	if(l==r)
	{
		tr[now].val=a[l];
		return cnt;
	}
	int mid=(l+r)>>1;
	tr[now].l=build(tr[now].l,l,mid);
	tr[now].r=build(tr[now].r,mid+1,r);
	return now;
}
int update(int now,int l,int r,int x,int val)
{
	cnt++; tr[cnt]=tr[now]; now=cnt;
	if(l==r)
	{
		tr[now].val=val;
		return now;
	}
	int mid=(l+r)>>1;
	if(x<=mid) tr[now].l=update(tr[now].l,l,mid,x,val);
	else tr[now].r=update(tr[now].r,mid+1,r,x,val);
	return now;
}
int query(int now,int l,int r,int x)
{
	if(l==r) return tr[now].val;
	int mid=(l+r)>>1;
	if(x<=mid) return query(tr[now].l,l,mid,x);
	else return query(tr[now].r,mid+1,r,x);
}
int main()
{
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	root[0]=build(0,1,n);
	int x,y,z,op;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d",&x,&op);
		if(op==1)
		{
			scanf("%d%d",&y,&z);
			root[i]=update(root[x],1,n,y,z);
		}
		else
		{
			scanf("%d",&y);
			printf("%d\n",query(root[x],1,n,y));
			root[i]=root[x];
		}
	}
	return 0;
}

 

可持久化线段树允许保留数据结构的多个历史版本,在实现代码修改以达成可持久化线段树时,要把握几个核心要点。 首先,其基本思路是有多棵线段树,相邻两棵线段树差别小,所以每棵线段树只需存储与前一棵的不同之处,使用时再修改填补并生成完整线段树,而且任意两棵线段树能“相减”得到包含题目解的新线段树[^4]。 在代码实现方面,若原本代码是普通线段树的实现,要进行如下修改: 1. **节点复制**:每次修改操作时,不能直接修改原节点,而是要复制受影响的节点,构建新的节点路径。比如修改某个区间时,沿着从根节点到该区间的路径,复制经过的每个节点。 2. **版本管理**:维护不同版本的线段树,每个版本指向对应线段树的根节点。可以用一个数组来存储各个版本的根节点指针。 以下是一个简单的 C# 示例代码框架,用于实现可持久化线段树的单点修改: ```csharp // 定义线段树节点类 class Node { public int left, right; // 节点表示的区间左右端点 public int sum; // 区间和 public Node leftChild, rightChild; // 左右子节点 public Node(int l, int r) { left = l; right = r; sum = 0; leftChild = rightChild = null; } } class PersistentSegmentTree { private Node[] roots; // 存储不同版本的根节点 private int versionCount; public PersistentSegmentTree(int[] arr) { roots = new Node[1000]; // 假设最多支持 1000 个版本 versionCount = 0; roots[versionCount] = BuildTree(arr, 0, arr.Length - 1); } // 构建初始线段树 private Node BuildTree(int[] arr, int left, int right) { Node node = new Node(left, right); if (left == right) { node.sum = arr[left]; } else { int mid = (left + right) / 2; node.leftChild = BuildTree(arr, left, mid); node.rightChild = BuildTree(arr, mid + 1, right); node.sum = node.leftChild.sum + node.rightChild.sum; } return node; } // 复制节点 private Node CloneNode(Node original) { Node clone = new Node(original.left, original.right); clone.sum = original.sum; clone.leftChild = original.leftChild; clone.rightChild = original.rightChild; return clone; } // 单点修改 public void Update(int version, int index, int value) { versionCount++; roots[versionCount] = UpdateNode(roots[version], index, value); } private Node UpdateNode(Node node, int index, int value) { Node newNode = CloneNode(node); if (node.left == node.right) { newNode.sum = value; } else { int mid = (node.left + node.right) / 2; if (index <= mid) { newNode.leftChild = UpdateNode(node.leftChild, index, value); } else { newNode.rightChild = UpdateNode(node.rightChild, index, value); } newNode.sum = newNode.leftChild.sum + newNode.rightChild.sum; } return newNode; } // 查询区间和 public int Query(int version, int left, int right) { return QueryNode(roots[version], left, right); } private int QueryNode(Node node, int left, int right) { if (left > node.right || right < node.left) { return 0; } if (left <= node.left && right >= node.right) { return node.sum; } return QueryNode(node.leftChild, left, right) + QueryNode(node.rightChild, left, right); } } ``` 使用示例: ```csharp class Program { static void Main() { int[] arr = { 1, 2, 3, 4, 5 }; PersistentSegmentTree pst = new PersistentSegmentTree(arr); // 初始版本查询 int sum1 = pst.Query(0, 0, 2); Console.WriteLine("初始版本 [0, 2] 的和: " + sum1); // 修改节点 pst.Update(0, 1, 10); // 新版本查询 int sum2 = pst.Query(1, 0, 2); Console.WriteLine("新版本 [0, 2] 的和: " + sum2); } } ``` 在这个示例中,`PersistentSegmentTree` 类用于管理可持久化线段树,`roots` 数组存储不同版本的根节点。`BuildTree` 方法构建初始线段树,`Update` 方法进行单点修改并生成新的版本,`Query` 方法用于查询指定版本的区间和。 同时,可持久化线段树的题目一般容易卡空间,在记忆模板时建议选择传参的模板,避免因开数组单独记录每个区间的左右端点而出现内存超限(MLE)的情况[^2]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值