线段树 区间修改区间查询

维护序列的二叉树

树上每个点对应序列上一段连续的区间

ls/rs:k的左/右儿子

Mid=(l+r)/2

若点x对应[l,r],则ls对应[l,mid],rs对应[mid+1,r]

根节点对应整个序列[1,n]

叶节点对应的区间为[l,l],即序列上一个点

1.区间加法

考虑用lazy数组标记,当我们需要对点k所对应的区间加v时,我们不递归k的左右子树更新其内部值,而是选择lazy[k]+=v,代表这段区间已经加过v了。当我们在查询和修改中遇到一个有懒标记的点k时,由于其子树内部的值还未被更新,我们需要将懒标记的影响下传到子树中,并将懒标记清空。

void add(int k,int l,int r,int v){
	s[k] += (r-l+1)*v;
	lazy[k] += v;
	return;
}
void pushdown(int k,int l,int r){
	add(ls,l,mid,lazy[k]);
	add(rs,mid+1,r,lazy[k]);
	lazy[k] = 0;
	return;
}

2.区间乘法

用两个lazy数组,表示加和成,其余的部分一样

void add(int k,int l,int r,int v1,int v2){//表示先乘v2再加v1
	s[k] = (s[k]*v2 + v1*(r-l+1))%mod;
	lazy1[k] = (lazy1[k]*v2 + v1)%mod;
	lazy2[k] = (lazy2[k]*v2)%mod;
	return;
}
void pushdown(int k,int l,int r){
	add(ls,l,mid,lazy1[k],lazy2[k]);
	add(rs,mid+1,r,lazy1[k],lazy2[k]);
	lazy1[k] = 0;
	lazy2[k] = 1; //注意要清成1
	return;
}

最后放上有加法和乘法的总代码

#include<bits/stdc++.h>
#define int long long
#define ll long long
#define ls (k<<1)
#define rs (k<<1|1)
#define mid (l+r>>1)
using namespace std;
inline int read(){
	int x=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch == '-') f=-1 ; ch=getchar();}
	while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48) ; ch=getchar();}
	return x*f;
}
const int M = 500010;
int n,m,mod;
int s[M*4],lazy1[M*4],lazy2[M],a[M];//jia cheng
void build(int k,int l,int r){
	lazy2[k] = 1;
	if(l == r){s[k] = a[l];return;}
	build(ls,l,mid);
	build(rs,mid+1,r);
	s[k] = (s[ls]+s[rs])%mod;
	return;
}
void add(int k,int l,int r,int v1,int v2){
	s[k] = (s[k]*v2 + v1*(r-l+1))%mod;
	lazy1[k] = (lazy1[k]*v2 + v1)%mod;
	lazy2[k] = (lazy2[k]*v2)%mod;
	return;
}
void pushdown(int k,int l,int r){
	add(ls,l,mid,lazy1[k],lazy2[k]);
	add(rs,mid+1,r,lazy1[k],lazy2[k]);
	lazy1[k] = 0;
	lazy2[k] = 1;
	return;
}
void pushup(int k,int l,int r){s[k] = (s[ls] + s[rs])%mod;}
int query(int k,int l,int r,int x,int y){
	if(x<=l && y>=r) return s[k];
	pushdown(k,l,r);
	int res = 0;
	if(x<=mid) res += query(ls,l,mid,x,y);
	if(y>mid) res += query(rs,mid+1,r,x,y);
	return res%mod;
}
void modify(int k,int l,int r,int x,int y,int v1,int v2){
	if(x<=l && y>=r){add(k,l,r,v1,v2);return;}
	pushdown(k,l,r);
	if(x<=mid) modify(ls,l,mid,x,y,v1,v2);
	if(y>mid) modify(rs,mid+1,r,x,y,v1,v2);
	pushup(k,l,r);
	return;
}
signed main(){
	n=read();m=read();mod=read();
	for(register int i(1) ; i<=n ; i=-~i) a[i] = read();
	build(1,1,n);
	for(register int i(1) ; i<=m ; i=-~i){
		int op;
		op=read();
		if(op == 1){
			int x,y,k;
			x=read();y=read();k=read();
			modify(1,1,n,x,y,0,k);
		}
		if(op == 2){
			int x,y,k;
			x=read();y=read();k=read();
			modify(1,1,n,x,y,k,1);
		}
		if(op == 3){
			int x,y;
			x=read();y=read();
			printf("%lld\n",query(1,1,n,x,y)%mod);
		}
	}
	return 0;
}

### 线段树实现区间修改后单点查询 线段树是一种高效的数据结构,能够支持快速的区间修改和单点查询操作。当执行区间修改之后,为了确保后续的单点查询仍然保持高效的性能,通常会采用懒惰传播(Lazy Propagation)技术来优化。 #### 懒惰传播机制简介 懒惰传播允许延迟处理区间的更新请求直到真正访问该节点为止。这意味着,在进行区间更新时不立即向下传递更改给子节点,而是标记这些子节点等待将来被访问时再做调整。这减少了不必要的计算次数并提高了效率[^2]。 #### 区间修改后的单点查询流程 1. 构建初始线段树。 2. 执行区间修改操作,并设置相应的懒惰标签。 3. 对于任何一次单点查询前先下推所有经过路径上的懒惰值至叶子节点。 4. 完成上述步骤后再定位目标位置获取最终结果。 以下是Python版本的具体实现: ```python class SegmentTree: def __init__(self, nums): self.n = len(nums) self.tree = [0] * (4 * self.n) # 存储线段树数值 self.lazy = [0] * (4 * self.n) # 存储懒加载标志位 def build(node, start, end): if start == end: self.tree[node] = nums[start] else: mid = (start + end) // 2 build(2*node+1, start, mid) build(2*node+2, mid+1, end) self.tree[node] = min(self.tree[2*node+1], self.tree[2*node+2]) build(0, 0, self.n-1) def update_range(self, node, start, end, l, r, val): if self.lazy[node]: self.tree[node] += self.lazy[node] if start != end: self.lazy[2*node+1] += self.lazy[node] self.lazy[2*node+2] += self.lazy[node] self.lazy[node] = 0 if start > end or start > r or end < l: return if start >= l and end <= r: self.tree[node] += val if start != end: self.lazy[2*node+1] += val self.lazy[2*node+2] += val return mid = (start + end)//2 self.update_range(2*node+1, start ,mid, l, r, val) self.update_range(2*node+2, mid+1, end, l, r, val) self.tree[node] = min(self.tree[2*node+1], self.tree[2*node+2]) def query_point(self, node, start, end, idx): if self.lazy[node]: self.tree[node] += self.lazy[node] if start != end: self.lazy[2*node+1] += self.lazy[node] self.lazy[2*node+2] += self.lazy[node] self.lazy[node] = 0 if start == end: return self.tree[node] mid = (start + end)//2 if idx <= mid: return self.query_point(2*node+1, start, mid, idx) else: return self.query_point(2*node+2, mid+1, end, idx) nums = [-1]*8 # 假设初始化数组大小为8 st = SegmentTree(nums) # 更新区间[1, 5]增加2 st.update_range(0, 0, st.n-1, 1, 5, 2) # 查询索引3处的值 print(st.query_point(0, 0, st.n-1, 3)) ``` 此代码展示了如何创建一个简单的带有懒惰传播特性的线段树用于处理区间加法运算及其对应的单点查询功能[^3]。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值