线段树知识点总结

于 2021-08-16 00:43:58 发布
阅读量141 收藏 2
点赞数 1
分类专栏： 线段树 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/turtlesd/article/details/119722597
版权
本文详细介绍了线段树的基本操作，包括单点修改、区间查询、区间修改（懒标记）、权值线段树、位运算结合线段树、复杂线段树更新以及与其他知识点结合的线段树应用，通过多个实例展示了线段树在解决区间问题上的强大能力。
摘要由CSDN通过智能技术生成

线段树

1、单点修改与区间查询

题目：洛谷：【模板】线段树 1
最基础的模板，不做解释，上代码：

#include<iostream>
#include<cstring>
using namespace std;
typedef long long LL;
const int N = 400010;
LL w[N];
int n,m;
struct Node{
	int l,r;
	LL sum,add;
}tr[N];
void pushup(int u){
	tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}
void pushdown(int u){
	Node &left = tr[u << 1],&right = tr[u << 1 | 1],&root = tr[u];
	if(root.add){
		left.add += root.add,left.sum += (LL)(left.r - left.l + 1) * root.add;
		right.add += root.add,right.sum += (LL)(right.r - right.l + 1) * root.add;
		root.add = 0;
	}
}
void build(int u,int l,int r){
	if(l == r) tr[u] = {l,r,w[l],0};
	else{
		tr[u] = {l,r};
		int mid = l + r >> 1;
		build(u << 1,l,mid),build(u << 1 | 1,mid + 1,r);
		pushup(u);
	}
}
void modify(int u,int l,int r,int d){
	if(tr[u].l >= l && tr[u].r <= r){
		tr[u].add += d;
		tr[u].sum += (LL)(tr[u].r - tr[u].l + 1) * d;
	}
	else{
		pushdown(u);
		int mid = tr[u].r + tr[u].l >> 1;
		if(l <= mid) modify(u << 1,l,r,d);
		if(r > mid) modify(u << 1 | 1,l,r,d);
		pushup(u);
	}
}
LL query(int u,int l,int r){
	if(tr[u].l >= l && tr[u].r <= r) return tr[u].sum;
	else{
		LL res = 0;
		int mid = tr[u].l + tr[u].r >> 1;
		pushdown(u);
		if(l <= mid) res += query(u << 1,l,r);
		if(r > mid) res += query(u << 1 | 1,l,r);
		return res;
	}
}
int main(){
	cin >> n >> m;
	for(int i = 1;i <= n;i ++) cin >> w[i];
	build(1,1,n);
	while(m --){
		int op;
		cin >> op;
		if(op == 1){
			int x,y,k;
			cin >> x >> y >> k;
			modify(1,x,y,k);
		}
		else{
			int x,y;
			cin >> x >> y;
			cout << query(1,x,y) << endl;
		}
	}
	return 0;
}

2、区间修改/懒标记

题目：洛谷：校门外的树
该题极其适合初学者练习区间修改（虽然是大材小用）
代码：

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 10010;
int n,m;
struct Tree{
	int l,r;
	int sum,lazy;
}tr[4 * N];
void pushup(int u){
	tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}
void pushdown(int u){
	Tree &root = tr[u],&left = tr[u << 1],&right = tr[u << 1 | 1];
	if(root.lazy){
		left.lazy = root.lazy,left.sum = 0;
		right.lazy = root.lazy,right.sum = 0;
		root.lazy = 0;
	}
}
void build(int u,int l,int r){
	if(l == r) tr[u] = {l,r,1,0};
	else{
		tr[u] = {l,r};
		int mid = l + r >> 1;
		build(u << 1,l,mid),build(u << 1 | 1,mid + 1,r);
		pushup(u);
	} 
}
void modify(int u,int l,int r){
	if(tr[u].l >= l && tr[u].r <= r){
		tr[u].lazy = 1;
		tr[u].sum = 0;
	}
	else{
		pushdown(u);
		int mid = tr[u].l + tr[u].r >> 1;
		if(l <= mid) modify(u << 1,l,r);
		if(r > mid) modify(u << 1 | 1,l,r);
		pushup(u);
	}
}
int main(){
	cin >> n >> m;
	build(1,1,n + 1);
	while(m --){
		int a,b;
		cin >> a >> b;
		modify(1,a + 1,b + 1);
	}
	cout << tr[1].sum;
	return 0;
}

3、权值线段树

权值线段树可以维护某个区间内数组元素出现的次数
题目:洛谷:逆序对
逆序对可以用归并排序、树状数组及线段树来求，但归并排序只能求这种最基本的逆序对，一旦题目稍微变化就需要用树状数组或线段树来解决。树状数组一般比线段树更方便，这里选择线段树来解决该问题。

在此题中，线段树维护的是每个点出现的次数。由于数据范围太大且分散，我们先将输入的a数组离散化，从而使每个数有序对应1~n。将a数组从左至右插入树中，每次插入后都查询一下该数（在书中对应的位置 + 1 , n） 这个区间的数的总数，这就是这个数对应的逆序对，最后将所有的逆序对加起来即为答案。记得开long long!!!
代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cstdio>
using namespace std;
typedef long long LL;
const int N = 500010;
int n;
int a[N];
vector<int> w;
struct Tree{
	int l,r;
	LL val;
}tr[N * 4];
void pushup(int u){
	tr[u].val = tr[u << 1].val + tr[u << 1 | 1].val;
}
void build(int u,int l,int r){
	if(l == r) tr[u] = {l,r,0};
	else{
		tr[u] = {l,r};
		int mid = l + r >> 1;
		build(u << 1,l,mid),build(u << 1 | 1,mid + 1,r);
		pushup(u);
	}
}
int find(int x){
    int l = 0,r = w.size() - 1;
    while(l < r){
        int mid = l + r >> 1;
        if(w[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return r + 1;
}
void modify(int u,int x){
	if(tr[u].l == tr[u].r && tr[u].l == x){
		tr[u].val ++;
	}
	else{
		int mid = tr[u].l + tr[u].r >> 1;
		if(x <= mid) modify(u << 1,x);
		else modify(u << 1 | 1,x);
		pushup(u);
	}
}
LL query(int u,int l,int r){
	if(tr[u].l >= l && tr[u].r <= r) return tr[u].val;
	LL res = 0;
	int mid = tr[u].l + tr[u].r >> 1;
	if(l <= mid) res += query(u << 1,l,r);
	if(r > mid) res += query(u << 1 | 1,l,r);
	pushup(u);
	return res; 
}
int main(){
	cin >> n;
	build(1,1,n);
	for(int i = 0;i < n;i ++){
		scanf("%d",&a[i]);
		w.push_back(a[i]);
	}
	sort(w.begin(),w.end());
	w.erase(unique(w.begin(),w.end()),w.end());
	LL ans = 0;
	for(int i = 0;i < n;i ++){
		int t = find(a[i]);
		modify(1,t);
		if(t != n) ans += query(1,t + 1,n);
	}
	cout << ans;
	return 0;
}

扩展：洛谷：三元上升子序列

该题是逆序对的扩展题，利用上题思想，从头到尾遍历区间，每个数的（前面比他小的数的个数 * 后面比他大的数的个数）之和即为答案，建立两个线段树，一个从头到尾存储，另一个从尾到头存储，分别计算前面比他小的数的个数和后面比他大的数的个数。

代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cstdio>
using namespace std;
typedef long long LL;
const int N = 500010;
int n;
LL a[N],s[N],ls[N];
vector<int> w;
struct Tree{
	int l,r;
	LL val;
};
Tree tr2[4 * N],tr1[N * 4];
void pushup(Tree tr[],int u){
	tr[u].val = tr[u << 1].val + tr[u << 1 | 1].val;
}
void build(Tree tr[],int u,int l,int r){
	if(l == r) tr[u] = {l,r,0};
	else{
		tr[u] = {l,r};
		int mid = l + r >> 1;
		build(tr,u << 1,l,mid),build(tr,u << 1 | 1,mid + 1,r);
		pushup(tr,u);
	}
}
int find(int x){
    int l = 0,r = w.size() - 1;
    while(l < r){
        int mid = l + r >> 1;
        if(w[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return r + 1;
}
void modify(Tree tr[],int u,int x){
	if(tr[u].l == tr[u].r && tr[u].l == x){
		tr[u].val ++;
	}
	else{
		int mid = tr[u].l + tr[u].r >> 1;
		if(x <= mid) modify(tr,u << 1,x);
		else modify(tr,u << 1 | 1,x);
		pushup(tr,u);
	}
}
LL query(Tree tr[],int u,int l,int r){
	if(tr[u].l >= l && tr[u].r <= r) return tr[u].val;
	LL res = 0;
	int mid = tr[u].l + tr[u].r >> 1;
	if(l <= mid) res += query(tr,u << 1,l,r);
	if(r > mid) res += query(tr,u << 1 | 1,l,r);
	pushup(tr,u);
	return res; 
}
int main(){
	cin >> n;
	for(int i = 0;i < n;i ++){
		scanf("%d",&a[i]);
		w.push_back(a[i]);
	}
	sort(w.begin(),w.end());
	w.erase(unique(w.begin(),w.end()),w.end());
	build(tr1,1,1,n);
	build(tr2,1,1,n);
	LL ans = 0;
	for(int i = 0;i < n;i ++){
		int t = find(a[i]);
		modify(tr1,1,t);
		if(t != 1) s[i] += query(tr1,1,1,t - 1);
	}
	for(int i = n - 1;i >= 0;i --){
		int t = find(a[i]);
		modify(tr2,1,t);
		if(t != n) ls[i] += query(tr2,1,t + 1,n);
	}
	for(int i = 1;i < n - 1;i ++)
		ans += s[i] * ls[i];
	cout << ans;
	return 0;
}

进阶：洛谷：冒泡排序
代码：

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 200010;
typedef long long LL;
int n,m;
LL a[N],p[N],c[N],w[N];
struct Tree{
	int l,r;
	LL cnt,sum;
}tr[N * 4];
void pushup(int u){
	tr[u].cnt = tr[u << 1].cnt + tr[u << 1 | 1].cnt;
	tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}
void build(int u,int l,int r){
	if(l == r)
		tr[u] = {l,r,w[l],w[l]* l};
	else{
		int mid = l + r >> 1;
		tr[u] = {l,r};
		build(u << 1,l,mid),build(u << 1 | 1,mid + 1,r);
		pushup(u);
	}
}
void modify(int u,int x,int v){
	if(tr[u].l == tr[u].r && tr[u].l == x){
		tr[u].cnt += v;
		tr[u].sum = tr[u].cnt * tr[u].l;
	}
	else{
		int mid = tr[u].l + tr[u].r >> 1;
		if(x <= mid) modify(u << 1,x,v);
		else modify(u << 1 | 1,x,v);
		pushup(u);
	}
}
LL cntquery(int u,int l,int r){
	if(tr[u].l >= l && tr[u].r <= r) return tr[u].cnt;
	LL res = 0;
	int mid = tr[u].l + tr[u].r >> 1;
	if(l <= mid) res = cntquery(u << 1,l,r);
	if(r > mid) res += cntquery(u << 1 | 1,l,r);
	pushup(u); 
	return res;
}
LL sumquery(int u,int l,int r){
	if(tr[u].l >= l && tr[u].r <= r) return tr[u].sum;
	LL res = 0;
	int mid = tr[u].l + tr[u].r >> 1;
	if(l <= mid) res = sumquery(u << 1,l,r);
	if(r > mid) res += sumquery(u << 1 | 1,l,r);
	pushup(u); 
	return res;
}
int main(){
	cin >> n >> m;
	build(1,1,n);
	for(int i = 1;i <= n;i ++){
		cin >> a[i];
		c[i] = cntquery(1,a[i],n);
		
	}
	for(int i = 1;i <= n;i ++) w[c[i]] ++;
	build(1,0,n - 1);
	while(m --){
		int op,x;
		cin >> op >> x;
		if(op == 2){
			if(x >= n - 1) cout << 0 << endl;
			else cout << sumquery(1,x + 1,n - 1) - cntquery(1,x + 1,n - 1) * x << endl;
		}
		else{
			modify(1,c[x],-1),modify(1,c[x + 1],-1);
			if(a[x] > a[x + 1]) c[x + 1] --;
			else c[x] ++ ;
			swap(c[x],c[x + 1]);
			swap(a[x],a[x + 1]);
			modify(1,c[x],1),modify(1,c[x + 1],1);
		}
	}
	return 0;
}

4、线段树&&位运算（拆位线段树）

一个线段树不可惧，但遇到位运算可就头疼了，比如下面这题：
洛谷：XOR on Segment
由操作一可知我们要维护区间和，但很明显，区间和与位运算操作不共融，所以我们需要将这些数拆成二进制位存储到线段树中进行操作，具体操作可以看洛谷题解。
代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
typedef long long LL;
const int N = 100010;
int n,m;
LL a[N],w[N];
struct Tree{
	int l,r;
	LL cnt,xors;
}tr[20][4 * N];
void pushup(int u,int i){
	tr[i][u].cnt = tr[i][u << 1].cnt + tr[i][u << 1 | 1].cnt;
}
void pushdown(int u,int i){
	Tree &root = tr[i][u],&left = tr[i][u << 1],&right = tr[i][u << 1 | 1];
	if(root.xors){
		left.xors ^= root.xors, left.cnt = (left.r - left.l + 1) - left.cnt;
		right.xors ^= right.xors,right.cnt = (right.r - right.l + 1) - right.cnt;
		root.xors = 0;
	}
}
void build(int i,int u,int l,int r){
	if(l == r) tr[i][u] = {l,r,(a[l] & w[i]) != 0,0};
	else{
		tr[i][u] = {l,r};
		int mid = l + r >> 1;
		build(i,u << 1,l,mid),build(i,u << 1 | 1,mid + 1,r);
		pushup(u,i);
	}
}
void modify(int i,int u,int l,int r){
	if(tr[i][u].l >= l && tr[i][u].r <= r){
		tr[i][u].xors ^= 1;
		tr[i][u].cnt = (tr[i][u].r - tr[i][u].l + 1) - tr[i][u].cnt;
	}
	else{
		pushdown(u,i);
		int mid = tr[i][u].l + tr[i][u].r >> 1;
		if(l <= mid) modify(i,u << 1,l,r);
		if(r > mid) modify(i,u << 1 | 1,l,r);
		pushup(u,i);
	}
}
LL query(int i,int u,int l,int r){
	if(tr[i][u].l >= l && tr[i][u].r <= r){
		return tr[i][u].cnt;
	}
	pushdown(u,i);
	int mid = tr[i][u].l + tr[i][u].r >> 1;
	LL res = 0;
	if(l <= mid) res = query(i,u << 1,l,r);
	if(r > mid) res += query(i,u << 1 | 1,l,r);
	pushup(u,i); 
	return res;
}
int main(){
	cin >> n;
	for(int i = 0;i < 20;i ++) w[i] = 1 << i;
	for(int i = 1;i <= n;i ++) scanf("%lld",&a[i]);
	for(int i = 0;i < 20;i ++) build(i,1,1,n);
	cin >> m;
	while(m --){
		int op,l,r;
		scanf("%d%d%d",&op,&l,&r);
		if(op == 1){
			LL ans = 0;
			for(int i = 0;i < 20;i ++){
				ans += query(i,1,l,r) * w[i];
			}
			printf("%lld\n",ans);
		}
		else{
			int x;
			scanf("%d",&x);
			for(int i = 0;i < 20;i ++)
				if(x & w[i]) modify(i,1,l,r);
		}
	}
	return 0;
}

5、较难pushup的线段树

题目：洛谷：STEP
该题中线段树父节点维护的值更新时不能只是对左右儿子节点的值简单的加减或者取最大值，还需要考虑左右儿子之间连接的部分。只要把pushup操作搞定，这道题的难点就被攻破了。
代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
const int N = 200010;
int n,m;
struct Tree{
	int l,r;
	int pre,last,all,le,ri;
}tr[4 * N];
void pushup(int u){
	Tree &root = tr[u],&left = tr[u << 1],&right = tr[u << 1 | 1];
	root.le = left.le,root.ri = right.ri;
	if(left.ri == right.le){
		root.pre = left.pre,root.last = right.last;
		root.all = max(left.all,right.all);
	}
	else{
		root.all = max(left.all,right.all);
		root.all = max(root.all,left.last + right.pre);
		if(left.all == left.r - left.l + 1)
			root.pre = left.all + right.pre;
		else
			root.pre = left.pre;
		if(right.all == right.r - right.l + 1)
			root.last = right.all + left.last;
		else
			root.last = right.last;
	}
}
void build(int u,int l,int r){
	if(l == r) tr[u] = {l,r,1,1,1,0,0};
	else{
		tr[u] = {l,r};
		int mid = l + r >> 1;
		build(u << 1,l,mid),build(u << 1 | 1,mid + 1,r);
		pushup(u);
	}
}
void modify(int u,int x){
	if(tr[u].l == tr[u].r && tr[u].l == x) tr[u].le ^= 1,tr[u].ri ^= 1;
	else{
		int mid = tr[u].l + tr[u].r >> 1;
		if(x <= mid) modify(u << 1,x);
		else modify(u << 1 | 1,x);
		pushup(u);
	}
}
int main(){
	cin >> n >> m;
	build(1,1,n);
	while(m --){
		int x;
		scanf("%d",&x);
		modify(1,x);
		cout << tr[1].all << endl;
	}
	return 0;
}

类似的：
洛谷：Hotel G
代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
const int N = 50010;
int n,m;
struct Tree{
	int l,r;
	int lmax,rmax,sum,lazy;
}tr[4 * N];
void pushup(int u){
	tr[u].sum = max(tr[u << 1].sum,tr[u << 1 | 1].sum);
	tr[u].sum = max(tr[u].sum,tr[u << 1].rmax + tr[u << 1 | 1].lmax);
	if(tr[u << 1].sum == tr[u << 1].r - tr[u << 1].l + 1)
		tr[u].lmax = tr[u << 1].sum + tr[u << 1 | 1].lmax;
	else
		tr[u].lmax = tr[u << 1].lmax;
	if(tr[u << 1 | 1].sum == tr[u << 1 | 1].r - tr[u << 1 | 1].l + 1)
		tr[u].rmax = tr[u << 1].rmax + tr[u << 1 | 1].sum;
	else
		tr[u].rmax = tr[u << 1 | 1].rmax;	
}
void pushdown(int u){
	Tree &root = tr[u],&left = tr[u << 1],&right = tr[u << 1 | 1];
	if(root.lazy){
		left.lazy = root.lazy,right.lazy = root.lazy;
		if(root.lazy == 1){
			left.lmax = left.rmax = left.sum = 0;
			right.lmax = right.rmax = right.sum = 0;
		}
		else if(root.lazy == 2){
			left.lmax = left.sum = left.rmax = left.r - left.l + 1;
			right.lmax = right.sum = right.rmax = right.r - right.l + 1;
		}
		root.lazy = 0;
	}
}
void build(int u,int l,int r){
	if(l == r) tr[u] = {l,r,1,1,1,0};
	else{
		tr[u] = {l,r};
		int mid = l + r >> 1;
		build(u << 1,l,mid),build(u << 1 | 1,mid + 1,r);
		pushup(u);
	}
}
void modify(int u,int l,int r,int x){
	if(tr[u].l >= l && tr[u].r <= r){
		tr[u].lazy = x;
		if(x == 1){
			tr[u].lmax = tr[u].rmax = tr[u].sum = 0;
		}
		else if(x == 2){
			tr[u].lmax = tr[u].rmax = tr[u].sum = tr[u].r - tr[u].l + 1;
		}
	}
	else{
		pushdown(u);
		int mid = tr[u].l + tr[u].r >> 1;
		if(l <= mid) modify(u << 1,l,r,x);
		if(r > mid) modify(u << 1 | 1,l,r,x);
		pushup(u);
	}
}
int query(int u,int len){
	if(tr[u].l == tr[u].r) return tr[u].l;
	pushdown(u);
	if(tr[u << 1].sum >= len) return query(u << 1,len);
	if(tr[u << 1].rmax + tr[u << 1 | 1].lmax >= len) return (tr[u].r + tr[u].l >> 1) - tr[u << 1].rmax + 1;
	else return query(u << 1 | 1,len);
}
int main(){
	cin >> n >> m;
	build(1,1,n);
	while(m --){
		int op;
		scanf("%d",&op);
		if(op == 1){
			int x;
			scanf("%d",&x);
			if(x > tr[1].sum) cout << 0 << endl;
			else{
				int left = query(1,x);
				printf("%d\n",left);
				modify(1,left,left + x - 1,1);
			}
		}
		else{
			int x,y;
			scanf("%d%d",&x,&y);
			modify(1,x,x + y - 1,2);
		}
	}
	return 0;
}

6、与其它知识点串接的线段树

题目：洛谷：New Year Tree
该题用到了树的dfs序及状态压缩，具体见洛谷题解。
代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
typedef long long LL;
const int N = 400010;
int in[N],out[N],timestamp,pos[N];
int h[N],e[2 * N],ne[2 * N],idx;
int n,m;
LL color[N];
struct Tree{
	int l,r;
	LL sum,lazy;
}tr[N * 4];
void add(int a,int b){
	e[idx] = b,ne[idx] = h[a],h[a] = idx ++;
}
void pushup(int u){
	tr[u].sum = tr[u << 1].sum | tr[u << 1 | 1].sum;
}
void pushdown(int u){
	Tree &root = tr[u],&left = tr[u << 1],&right = tr[u << 1 | 1];
	if(root.lazy){
		left.lazy = root.lazy,left.sum = 1ll << root.lazy;
		right.lazy = root.lazy,right.sum = 1ll << root.lazy;
		root.lazy = 0;
	}
}
void build(int u,int l,int r){
	if(l == r) tr[u] = {l,r,1ll << color[pos[l]],0};
	else{
		tr[u] = {l,r};
		int mid = tr[u].l + tr[u].r >> 1;
		build(u << 1,l,mid),build(u << 1 | 1,mid + 1,r);
		pushup(u); 
	}
}
void modify(int u,int l,int r,LL c){
	if(tr[u].l >= l && tr[u].r <= r){
		tr[u].lazy = c;
		tr[u].sum = 1ll << c;
	}
	else{
		pushdown(u);
		int mid = tr[u].l + tr[u].r >> 1;
		if(l <= mid) modify(u << 1,l,r,c);
		if(r > mid) modify(u << 1 | 1,l,r,c);
		pushup(u);
	}
}
LL query(int u,int l,int r){
	if(tr[u].l >= l && tr[u].r <= r) return tr[u].sum;
	LL res = 0;
	pushdown(u);
	int mid = tr[u].l + tr[u].r >> 1;
	if(l <= mid) res = query(u << 1,l,r);
	if(r > mid) res |= query(u << 1 | 1,l,r);
	pushup(u);
	return res;
}
LL lowbit(LL x){
	return x & (-x);
}
void dfs(int x,int fa){
	++ timestamp;
	in[x] = timestamp;
	pos[timestamp] = x;
	for(int i = h[x];i != -1;i = ne[i]){
		int j = e[i];
		if(j != fa){
			dfs(j,x);
		}
	}
	out[x] = timestamp;
}
int main(){
	cin >> n >> m;
	memset(h,-1,sizeof h);
	for(int i = 1;i <= n;i ++) cin >> color[i];
	for(int i = 1;i < n;i ++){
		int a,b;
		scanf("%d%d",&a,&b);
		add(a,b),add(b,a);
	}
	dfs(1,-1);
	build(1,1,n);
	while(m --){
		int op,x;
		scanf("%d%d",&op,&x);
		if(op == 1){
			LL c;
			scanf("%lld",&c);
			int l = in[x],r = out[x];
			modify(1,l,r,c);
		}
		else{
			int l = in[x],r = out[x];
			LL ans = 0;
			LL t = query(1,l,r);
			for(LL i = t;i;i -= lowbit(i)) ans += 1;
			cout << ans << endl;
		}
	}
	return 0;
}

7、对区间修改操作进行暴力单点修改的线段树

题目：洛谷：The Child and Sequence
由于取模操作与区间和不能共容，需要对其进行暴力取模，由于当区间最大值小于模数时，该区间取模不会发生改变，故可对此做一个优化，在modify操作中可见。
代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
const int N = 100010;
typedef long long LL;
int n,m;
LL w[N];
struct Tree{
	int l,r;
	LL sum,maxn;
}tr[4 * N];
void pushup(int u){
	tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
	tr[u].maxn = max(tr[u << 1].maxn,tr[u << 1 | 1].maxn);
}
void build(int u,int l,int r){
	if(l == r) tr[u] = {l,r,w[l],w[l]};
	else{
		tr[u] = {l,r};
		int mid = l + r >> 1;
		build(u << 1,l,mid),build(u << 1 | 1,mid + 1,r);
		pushup(u);
	}
}
void mod(int u,int l,int r,int x){
	if(tr[u].maxn < x) return;
	if(tr[u].l >= l && tr[u].r <= r && tr[u].l == tr[u].r)
		tr[u].sum = tr[u].maxn = tr[u].sum % x;
	else{
		int mid = tr[u].l + tr[u].r >> 1;
		if(l <= mid) mod(u << 1,l,r,x);
		if(r > mid) mod(u << 1 | 1,l,r,x);
		pushup(u);
	}
}
void modify(int u,int x,int t){
	if(tr[u].l == tr[u].r && tr[u].l == x)
		tr[u].maxn = tr[u].sum = t;
	else{
		int mid = tr[u].l + tr[u].r >> 1;
		if(x <= mid) modify(u << 1,x,t);
		else modify(u << 1 | 1,x,t);
		pushup(u);
	}
}
LL query(int u,int l,int r){
	if(tr[u].l >= l && tr[u].r <= r) return tr[u].sum;
	LL res = 0;
	int mid = tr[u].l + tr[u].r >> 1;
	if(l <= mid) res = query(u << 1,l,r);
	if(r > mid) res += query(u << 1 | 1,l,r);
	pushup(u);
	return res;
}
int main(){
	cin >> n >> m;
	for(int i = 1;i <= n;i ++) cin >> w[i];
	build(1,1,n);
	while(m --){
		int op;
		scanf("%d",&op);
		if(op == 1){
			int l,r;
			scanf("%d%d",&l,&r);
			printf("%lld\n",query(1,l,r));
		}
		else if(op == 2){
			int l,r,x;
			scanf("%d%d%d",&l,&r,&x);
			mod(1,l,r,x);
		}
		else{
			int x,t;
			scanf("%d%d",&x,&t);
			modify(1,x,t);
		}
	}
	return 0;
}
见过自讼
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树总结
11-27 2万+
之前做了些线段树相关的题目，开学一段时间后，想着把它整理下，完成了大牛NotOnlySuccess的博文“完全版线段树”里的大部分题目，其博文地址Here，然后也加入了自己做过的一些题目。整理时，更新了之前的代码风格，不过旧的代码仍然保留着。       同样分成四类，不好归到前四类的都分到了其他。树状数组能做，线段树都能做（如果是内存限制例外），所以也有些树状数组的题目，会标示出来，并且放到其
线段树知识点总结和学习心得分享
weixin_45590210的博客
05-05 256
线段树主要用来维护复杂的区间信息.只要满足区间可加性,线段树基本都可以解决. 1.线段树基本操作(单点更新,区间求和等不涉及lazy标记问题) 先来讲建树问题,线段树建树有很多种方法,本文介绍的是把一个区间划分成为[l,mid],[mid+1,r]的建树方法. 我们会把一个大区间分成若干个小区间,tree[1]是表示整个大区间.把它分成两个小区间.用下标tree[2×father], tree[2...
线段树知识点
JKdd123456的博客
07-31 357
首先线段树能解决什么问题 假设有编号从1到n的n个点，每个点都存了一些信息，用[L,R]表示下标从L到R的这些点。 线段树的用处就是，对编号连续的一些点进行修改或者统计操作，修改和统计的复杂度都是O(log2(n)). 线段树的原理，就是，将[1,n]分解成若干特定的子区间(数量不超过4*n),然后，将每个区间[L,R]都分解为 少量特定的子区间，通过对这些少量子区间的修改或者统计，来实现...
线段树小总结
01-02
### 线段树小总结 #### 知识点概述 线段树是一种高效的数据结构，主要用于处理区间查询和更新的问题。它通过将一个数组区间分割成若干个不重叠的小区间来加速查询和更新操作。线段树的每个节点通常存储关于其对应...
线段树高级数据结构实现
05-26
### 线段树高级数据结构实现：点更新 #### 一、线段树简介 线段树是一种高效的数据结构，常用于处理区间查询或区间更新的问题。它将一个线性序列分割成多个部分，每个节点代表一个区间的统计信息（如最大值、...
全国计算机等级考试VB知识点总结全部.doc
最新发布
11-29
全国计算机等级考试 VB 知识点总结 本文档主要总结了全国计算机等级考试 VB 知识点的相关内容，包括数据结构、算法、线性表、栈、队列等知识点的详细解释和总结。 1.1 算法 算法是指解题方案的准确而完整的描述。...
遍历线段树
05-18
### 遍历线段树知识点详解 #### 一、线段树简介 线段树是一种二叉树数据结构，用于高效地处理区间查询或更新问题。它将一个区间分割成多个不重叠的小区间，并将这些小区间存储在树的不同节点上。每个节点代表一个...
线段树应用
Ma_tx
08-11 3517
下面给出线段树的几个应用： （1）有一列数，初始值全部为0。每次可以进行以下三种操作中的一种： a. 给指定区间的每个数加上一个特定值； b.将指定区间的所有数置成一个统一的值； c.询问一个区间上的最小值、最大值、所有数的和。 给出一系列a.b.操作后，输出c的结果。 [问题分析] 这个是典型的线段树的应用。在每个节点上维护一下几个变量：delta（区间增加值），same（区间被置
acm常见算法考点_线段树
一只懒猫的博客
07-30 172
功能： 区间查询和单点修改。 线段树的本质就是采用空间换取时间的方式，将数组的每一个可能的区间的结果都存储到一个树里面，这样在查询是就很快。因为采用二叉树的形式存储，所以修改区间内一个值的也是log级别的。 大概就是这样的一颗树，因为区间二分的平衡性，所以刚刚建立的一颗树肯定是一颗平衡树。所以为了方便，采用静态数组的方式存储树，类丝与堆的方式。 代码： #include<iostream> using namespace std; const int N = 1e5 + 5; int a
优化升级：线段树经典解法全面解析
本文档分享的是ACM大牛对线段树的经典总结，特别针对初学者提供了改进后的教学内容。作者之前的一篇文章虽然点击量大，但代码风格已显过时，因此决定重新编写，提升教学质量和代码可读性。 1. 节点设计与初始化： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值