延迟标记 (线段树)

延迟标记

在线段树中,单点修改时,我们是将信息从叶节点向上依次更新它的父节点,直到根节点。如果在区间修改仍然按照这个策略,那么修改的时间复杂度为O(N)。
为了降低时间复杂度,我们可以在更新时只更新大区间,不向下更新到叶子节点,等查询时再更新。举个例子:我们将1-5的位置上每个数+100,重复10000次上述操作。我们加10000次100和直接+1000000是相等的效果,但是一个执行了10000次,而另一个只执行1次。 我们又知道计算机的计算效率和计算次数是相关的,所以我们可以利用该原理,当区间修改时不向下更新,直至查询时再更新。

例题

以POJ3468为例,我们使用线段树+延迟标记技巧 来实现快速区间修改与区间查询。
具体做法是,我们为每个节点增加一个延迟标记add,如果add为0,则说明该点的所有子区间都已更新完成,否则说明其子区间仍需要+add。请注意,如果一个节点被打上“延迟标记”,说明该节点曾经被修改过,但其子节点尚未被更新,即延迟标记说明的是子节点的待更新情况。
具体实现时,我们可以使用一个函数spread来实现延迟标记向下传递。

代码示例:
 

#include<cstdio>
const int MAXN = 1e5+50;
typedef long long ll;
struct SegmentTree{
	int l,r;
	ll sum,add;
	#define l(x) t[x].l
	#define r(x) t[x].r
	#define sum(x) t[x].sum
	#define add(x) t[x].add
}t[MAXN*4];
 
int a[MAXN],n,m;
//将延迟标记向下更新一层 
inline void spread(int p){
	if(add(p)){
		sum(p*2) += (r(p*2) - l(p*2) + 1)*add(p);
		sum(p*2+1) += (r(p*2+1) - l(p*2+1) + 1)*add(p);
		add(p*2) += add(p);
		add(p*2+1) += add(p);
		add(p) = 0;
	}
}
//建树  l和r是当前节点所代表的区间的左右端点 
void build(int p,int l,int r){
	l(p) = l,r(p) = r,add(p) = 0;
	if(l == r){
		t[p].sum = a[l];
		return;
	}
	int mid = (l+r)/2;
	build(p*2,l,mid);
	build(p*2+1,mid+1,r);
	t[p].sum = t[p*2].sum + t[p*2+1].sum; 
}
//区间更新 如果当前区间被包含 则延迟标记 
void change(int p,int l,int r,int d){
	if(l <= l(p) && r(p) <= r){
		sum(p) += (r(p)-l(p)+1)*d;
		add(p) += d;
		return;
	}
	spread(p);
	int mid = (l(p)+r(p))/2;
	if(l <= mid) change(p*2,l,r,d);
	if(r > mid) change(p*2+1,l,r,d);
	sum(p) = sum(p*2) + sum(p*2+1);
}
//区间查询 当查询到该区间时顺便更新 
ll ask(int p,int l,int r){
//	printf("%d %d\n",l(p),r(p));
	if(l <= l(p) && r(p) <= r){
		return sum(p);
	}
	ll ans = 0;
	spread(p);
	int mid = (l(p) + r(p))/2;
	if(l <= mid) ans += ask(p*2,l,r);
	if(r > mid) ans += ask(p*2+1,l,r);
	return ans;
}
int main(){
	scanf("%d%d",&n,&m);
	for(int i = 1;i <= n;i++) scanf("%d",a+i);
	build(1,1,n);
	while(m--){
		char op[5];
		scanf("%s",op);
		if(op[0] == 'C'){
			int l,r,d;
			scanf("%d%d%d",&l,&r,&d);
			change(1,l,r,d);
		}else{
			int l,r;
			scanf("%d%d",&l,&r);
			printf("%lld\n",ask(1,l,r));
		}
	}
	return 0;
}

 

### 线段树懒加载(Lazy Propagation)实现 线段树是一种高效的数据结构,常用于解决区间查询和修改问题。为了优化性能,在涉及大量连续区间的更新操作时,通常会引入懒惰传播机制(Lazy Propagation)。这种技术通过延迟更新的方式减少了不必要的递归调用。 以下是基于 C++ 的线段树懒加载标记的代码模板: ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = 1e5 + 5; long long tree[4 * MAXN], lazy[4 * MAXN]; // 定义线段树数组和懒加载数组 int n; // 数组长度 // 建立初始线段树 void build(int node, int start, int end) { if (start == end) { // 如果到达叶子节点 tree[node] = 0; // 初始化为默认值 return; } int mid = (start + end) / 2; build(2 * node, start, mid); // 构建左子树 build(2 * node + 1, mid + 1, end); // 构建右子树 tree[node] = tree[2 * node] + tree[2 * node + 1]; // 合并左右子树的结果 } // 下推懒加载标记至子节点 void push_down(int node, int start, int end) { if (lazy[node]) { int mid = (start + end) / 2; lazy[2 * node] += lazy[node]; lazy[2 * node + 1] += lazy[node]; tree[2 * node] += (mid - start + 1) * lazy[node]; // 更新左子树 tree[2 * node + 1] += (end - mid) * lazy[node]; // 更新右子树 lazy[node] = 0; // 清除当前节点的懒标记 } } // 区间更新 [l, r] 加上 val void update_range(int node, int start, int end, int l, int r, long long val) { if (r < start || end < l) { // 当前区间完全不在目标范围内 return; } if (l <= start && end <= r) { // 当前线段被完全覆盖 tree[node] += (end - start + 1) * val; // 更新当前节点 lazy[node] += val; // 设置懒标记 return; } push_down(node, start, end); // 将懒标记传递给子节点 int mid = (start + end) / 2; update_range(2 * node, start, mid, l, r, val); // 更新左子树 update_range(2 * node + 1, mid + 1, end, l, r, val); // 更新右子树 tree[node] = tree[2 * node] + tree[2 * node + 1]; // 合并左右子树结果 } // 查询区间 [l, r] 的总和 long long query_sum(int node, int start, int end, int l, int r) { if (r < start || end < l) { // 当前区间完全不在目标范围内 return 0; } if (l <= start && end <= r) { // 当前线段被完全覆盖 return tree[node]; } push_down(node, start, end); // 将懒标记传递给子节点 int mid = (start + end) / 2; long long p1 = query_sum(2 * node, start, mid, l, r); // 左子树查询 long long p2 = query_sum(2 * node + 1, mid + 1, end, l, r); // 右子树查询 return p1 + p2; // 返回两部分之和 } ``` #### 关键点解析 - **`tree[]` 和 `lazy[]`** 是两个核心数组,分别表示线段树中的实际值以及懒标记。 - **`push_down()` 函数** 负责将父节点上的懒标记传递到其子节点,并清除自身的懒标记[^3]。 - **`update_range()` 函数** 实现了对指定范围内的所有元素加上某个固定值的功能,同时利用懒标记来减少冗余计算。 - **`query_sum()` 函数** 则实现了快速求解某一段区间的累加和功能。 上述代码展示了如何构建一棵支持懒加载的线段树,并提供了区间更新与查询的能力。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值