线段树--区间更新模板

最新推荐文章于 2022-01-06 22:28:33 发布
最新推荐文章于 2022-01-06 22:28:33 发布
阅读量2.1k 收藏
点赞数
分类专栏： 随笔 文章标签： 线段树 区间更新 模板 ACM 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40160605/article/details/81506801
版权

练板子题目

Hihocoder #1077

Hihocoder #1078

Hihocoder #1079

Hihocoder #1080

Hihocoder #1116

线段树--区间更新1模板

区间更新的操作为在区间增加权值wei

对应题目POJ - 3468 A Simple Problem with Integers 

#include<iostream>
using namespace std;
/****************************线段树区间更新1模板**************************************/ 
#define ll long long
const int maxn = 100010;
const ll inf =0x3f3f3f3f;
const ll mod=10007;
ll sums;        //全局变量记录区间和 
ll mins;       //全局变量记录区间最值 
ll num[maxn];  //原序列 
struct Brraacks {  //线段树结点 
	ll left,rigth,sum,Min,lazy;    //结点表示的区间[left,right],区间和sum,区间最小值Min,懒惰标记lazy 
} army[maxn * 4];
inline void Build(ll left, ll rigth, ll k) {   //从第k个结点开始，建立区间[left,right]的结点，并初始化这些结点 
	army[k].left = left;
	army[k].rigth = rigth;
	army[k].Min = inf;
	army[k].lazy = 0;
	army[k].sum=0;
	if (left == rigth) return;
	ll mid = (left + rigth) >>1;
	Build(left, mid, k<<1);
	Build(mid + 1, rigth, k<<1|1);
}
inline void Insert(ll wei, ll pos, ll k) {    //从第k个结点开始查找，找到区间[pos,pos]并加上值wei 
	if (army[k].left == army[k].rigth&&army[k].left == pos) {
		army[k].sum = wei;
		army[k].Min = army[k].sum;
		return;
	}
	ll mid = (army[k].left + army[k].rigth) >>1;
	if (pos <= mid)	Insert(wei, pos, k<<1);
	else Insert(wei, pos, k<<1|1);
	army[k].sum = army[k<<1].sum +army[k<<1|1].sum;    //回溯修改第k个结点的sum 
	army[k].Min = min(army[k<<1].Min, army[k<<1|1].Min);
}
inline void pushdown(ll k) {    //将第k个结点的懒惰标记推到他的儿子结点，并更新儿子结点的信息 
	if (army[k].lazy != 0) {
		army[k<<1].sum += (army[k<<1].rigth - army[k<<1].left + 1)*army[k].lazy;
		army[k<<1|1].sum += (army[k<<1|1].rigth - army[k<<1|1].left + 1)*army[k].lazy;
		army[k<<1].lazy += army[k].lazy;
		army[k<<1|1].lazy += army[k].lazy;
		army[k<<1].Min += army[k].lazy;
		army[k<<1|1].Min += army[k].lazy;
		army[k].lazy = 0;
	}
}
 
inline void Update(ll wei, ll l, ll r, ll k) {   //从第k个结点开始查找，找到区间[l,r],区间内的所有点加上wei 
	ll left = army[k].left;
	ll rigth = army[k].rigth;
	if (l <= left&&rigth <= r) {
		army[k].sum += (rigth - left + 1)*wei;
		army[k].lazy += wei;
		army[k].Min += wei;
		return;
	}
	pushdown(k);
	ll mid = (left + rigth) >>1;
	if (l >= mid + 1) Update(wei, l, r, k<<1|1);
	else if (mid >= r) Update(wei, l, r, k<<1);
	else {
		Update(wei, l, r, k<<1);
		Update(wei, l, r, k<<1|1);
	}
	army[k].sum = army[k<<1].sum + army[k<<1|1].sum;
	army[k].Min = min(army[k<<1].Min, army[k<<1|1].Min);
}
inline void Search(ll left, ll rigth, ll k) {   //从第k个结点开始查找，找到区间[left,right],返回区间和(最值) 
	if (left == army[k].left&&rigth == army[k].rigth) {
		sums += army[k].sum;
		mins = min(mins, army[k].Min);
		return;
	}
	pushdown(k);
	ll mid = (army[k].left + army[k].rigth) >>1;
	if (rigth <= mid) Search(left, rigth, k<<1);
	else if (left >= mid + 1) Search(left, rigth, k<<1|1);
	else {
		Search(left, mid, k<<1);
		Search(mid + 1, rigth, k<<1|1);
	}
}
inline void build(ll l,ll r) {   //建立(l,r)的线段树 
	Build(l,r,1);
}
inline void insert(ll wei,ll pos) {   //在pos点加权值wei 
	Insert(wei,pos,1);
}
inline void update(ll wei,ll l,ll r){  //在区间[l,r]内的所有点加上wei 
	Update(wei,l,r,1);
}
inline ll search(ll l,ll r) {     //在区间[l,r]返回区间和(最值) 
	sums=0;
	mins=inf;
	Search(l,r,1);
	//return sums;
    return sums;
}
/****************************线段树区间更新1模板**************************************/ 
int main() {
	int n,q;
	char str[3];
	int l,r;
	ll w;
	while(~scanf("%d %d",&n,&q)) {
		for(int i=1; i<=n; i++) scanf("%lld",&num[i]);
		build(1,n);
		for(int i=1; i<=n; i++)insert(num[i],i);
		for(int i=1; i<=q; i++) {
			scanf("%s",str);
			if(str[0]=='Q') {
				scanf("%d %d",&l,&r);
				ll ans=search(l,r);
				printf("%lld\n",ans);
			} else {
				scanf("%d %d %lld",&l,&r,&w);
				update(w,l,r);
			}
		}
	}
	return 0;
}

线段树--区间更新2模板

区间更新的操作为在区间增加一个权值wei，或者将区间的权值权值全部设置为wei

对应题目Hihocoder #1080 : 更为复杂的买卖房屋姿势

#include<iostream>
#include<map>
#include<algorithm>
#include<cstring>
using namespace std;
/**********************线段树区间更新模板2**************************************************/ 
#define ll long long
const int maxn = 100010;
const ll inf =0x3f3f3f3f;
const ll mod=10007;
ll sums;        //全局变量记录区间和
ll mins;       //全局变量记录区间最值
ll num[maxn<<1];  //原序列
struct Brraacks {  //线段树结点
	ll left,rigth,sum,Min,lazy,flag;    //结点表示的区间[left,right],区间和sum,区间最小值Min,懒惰标记lazy
} army[maxn * 4];
inline void Build(ll left, ll rigth, ll k) {   //从第k个结点开始，建立区间[left,right]的结点，并初始化这些结点
	army[k].left = left;
	army[k].rigth = rigth;
	army[k].Min = inf;
	army[k].lazy = 0;
	army[k].sum=0;
	army[k].flag=0;
	if (left == rigth) return;
	ll mid = (left + rigth) >>1;
	Build(left, mid, k<<1);
	Build(mid + 1, rigth, k<<1|1);
}
inline void Insert(ll wei, ll pos, ll k) {    //从第k个结点开始查找，找到区间[pos,pos]并加上值wei
	if (army[k].left == army[k].rigth&&army[k].left == pos) {
		army[k].sum = wei;
		army[k].Min = army[k].sum;
		return;
	}
	ll mid = (army[k].left + army[k].rigth) >>1;
	if (pos <= mid)	Insert(wei, pos, k<<1);
	else Insert(wei, pos, k<<1|1);
	army[k].sum = army[k<<1].sum +army[k<<1|1].sum;    //回溯修改第k个结点的sum
	army[k].Min = min(army[k<<1].Min, army[k<<1|1].Min);
}
inline void pushdown(ll k) {    //将第k个结点的懒惰标记推到他的儿子结点，并更新儿子结点的信息
	if (army[k].lazy != 0) {
		if(army[k].flag) {
			army[k<<1].sum = (army[k<<1].rigth - army[k<<1].left + 1)*army[k].lazy;
			army[k<<1|1].sum = (army[k<<1|1].rigth - army[k<<1|1].left + 1)*army[k].lazy;
			army[k<<1].lazy = army[k].lazy;
			army[k<<1|1].lazy = army[k].lazy;
			army[k<<1].Min = army[k].lazy;
			army[k<<1|1].Min = army[k].lazy;
			army[k].lazy = 0;
			army[k<<1].flag=1;
			army[k<<1|1].flag=1;
			army[k].flag=0;
		} else {
			if(army[k<<1].flag)	pushdown(k<<1);
			if(army[k<<1|1].flag) pushdown(k<<1|1);
			army[k<<1].sum += (army[k<<1].rigth - army[k<<1].left + 1)*army[k].lazy;
			army[k<<1|1].sum += (army[k<<1|1].rigth - army[k<<1|1].left + 1)*army[k].lazy;
			army[k<<1].lazy += army[k].lazy;
			army[k<<1|1].lazy += army[k].lazy;
			army[k<<1].Min += army[k].lazy;
			army[k<<1|1].Min += army[k].lazy;
			army[k].lazy = 0;
		}
	}
}

inline void Update(bool flag,ll wei, ll l, ll r, ll k) {   //从第k个结点开始查找，找到区间[l,r],falg为0则区间内的所有点加上wei，flag为1则将区间内的所有点设置为wei
	ll left = army[k].left;
	ll rigth = army[k].rigth;
	if (l <= left&&rigth <= r) {
		if(flag) {
			army[k].sum = (rigth - left + 1)*wei;
			army[k].lazy = wei;
			army[k].Min = wei;
			army[k].flag=1;
			return;
		} else {
			army[k].sum += (rigth - left + 1)*wei;
			army[k].lazy += wei;
			army[k].Min += wei;
			return;
		}
	}
	pushdown(k);
	ll mid = (left + rigth) >>1;
	if (l >= mid + 1) Update(flag,wei, l, r, k<<1|1);
	else if (mid >= r) Update(flag,wei, l, r, k<<1);
	else {
		Update(flag,wei, l, r, k<<1);
		Update(flag,wei, l, r, k<<1|1);
	}
	army[k].sum = army[k<<1].sum + army[k<<1|1].sum;
	army[k].Min = min(army[k<<1].Min, army[k<<1|1].Min);
}

inline void Search(ll left, ll rigth, ll k) {   //从第k个结点开始查找，找到区间[left,right],返回区间和(最值)
	if (left == army[k].left&&rigth == army[k].rigth) {
		sums += army[k].sum;
		mins = min(mins, army[k].Min);
		return;
	}
	pushdown(k);
	ll mid = (army[k].left + army[k].rigth) >>1;
	if (rigth <= mid) Search(left, rigth, k<<1);
	else if (left >= mid + 1) Search(left, rigth, k<<1|1);
	else {
		Search(left, mid, k<<1);
		Search(mid + 1, rigth, k<<1|1);
	}
}
inline void build(ll l,ll r) {   //建立(l,r)的线段树
	Build(l,r,1);
}
inline void insert(ll wei,ll pos) {   //在pos点加权值wei
	Insert(wei,pos,1);
}
inline void update(ll wei,ll l,ll r,bool flag) { //flag=0则在区间[l,r]内的所有点加上wei
	Update(flag,wei,l,r,1);                      //flag=1则在将区间[l,r]内的所有点设置为wei
}
inline ll search(ll l,ll r) {     //在区间[l,r]返回区间和(最值)
	sums=0;
	mins=inf;
	Search(l,r,1);
	//return sums;
	return sums;
}
/**********************线段树区间更新模板2**************************************************/ 
int L[maxn],R[maxn];
bool vis[maxn];
map<int,int>maps;
void debug(int n,int m) {
	for(int i=1;i<=n;i++){
		printf("%d %d\n",maps[L[i]],maps[R[i]]);
	}
	for(int i=1; i<=m; i++) {
		ll sum_=search(i,i);
		printf("%lld ",sum_);
	}
	cout<<endl;
}

int  Hash(int n) {
	sort(num+1,num+2*n+1);
	int tol=0;
	for(int i=1; i<=n<<1; i++) {
		if(maps[num[i]]==0)
			maps[num[i]]=++tol;
	}
	return tol;
}
int main() {
	int n,_L;
	while(~scanf("%d %d",&n,&_L)) {
		for(int i=1; i<=n; i++) {
			scanf("%d %d",&L[i],&R[i]);
			num[i]=L[i];
			num[n+i]=R[i];
		}
		memset(vis,0,sizeof(vis));
		maps.clear();
		int m=Hash(n);
		build(1,m);
		int cnt=0;
		for(int i=1; i<=n; i++) {
			int l=maps[L[i]]+1;
			int r=maps[R[i]];
			update(i,l,r,1);
		}
		//debug(n,m);
		vis[0]=1;
		for(int i=1; i<=m; i++) {
			ll tmp=search(i,i);
			if(vis[tmp]==0) {
				cnt++;
				vis[tmp]=1;
			}
		}
		printf("%d\n",cnt);
	}
	return 0;
}

 

brandong
关注
专栏目录
线段树区间更新模板——懒标记（lazy-tag）的运用
Plus Ultra！
05-11 1522
前言 在线段树中会遇到区间更新的情况，例如 在区间求和问题中，令[a,b]区间内的值全部加c，若此时再采用单点更新的方法，就会耗费大量时间，这个时候就要用到懒标记来进行区间更新了。 懒标记（lazy-tag），又叫做延迟标记，举例说明。 设 当前结点对应区间[l, r]，待更新区间[a, b] 　当 a ≤ l ≤ r ≤ b，即 [l, r]∈[a,b]时，不再向下更新，仅更新当前结...
线段树区间更新的模板
weixin_43140321的博客
07-31 208
1.线段树区间最大值更新代码模板 class SegTree { private: int _start, _end, _mid; SegTree*_left, *_right; int _sum; int _lazy; public: SegTree(int start,int end) { _start = start, _end = end; _mid = _start + (_end - _start) / 2; _left = NULL, _right = NULL;
ACM_线段树模板（区间更新）
知足常乐的博客
08-15 603
#include <iostream> #include <bits/stdc++.h> using namespace std;int ans[1000000],n; struct node { int l,r,n; }a[1000000]; void build(int left, int right ,int root) { a[root].l = left; a[ro
线段树区间更新
Enstein_Jun
04-11 3363
在此我们之前学习了线段树的单点更新(点我)。但是现在我们遇到一个这样的问题： 给出一个n个元素的数组A1,A2,...,An。我们总共进行m次操作。每次操作为下列两种操作其中一种： 1、Add(L, R, v): 将A(L), A(L+1),...,A(R)的值全部增加v。 2、Query(L, R): 计算子序列A(L), A(L+1),...,A(R)的元素和，最小值和最大值。 注意：A(L
线段树模板 区间更新
jkchen's Haven
04-20 338
原题：SPOJ - IITWPC4F 题意： 有个1e5*1e5的矩阵，初始化所有位置为0，有以下三种操作： x l r 把所有x在[l,r]区间的点反转（0变1，1变0） y l r 把所有y在[l,r]区间的点反转（0变1，1变0） q x1 y1 x2 y2 求以(x1,y1)，(x2,y2)为顶点的矩阵内1的个数 解析： 多次更新和查询，还是区间更新，那么就是线段树了 x轴...
线段树 - java通用模板
WSSB____的博客
01-06 406
LeetCode-307 线段树是一种非常灵活的数据结构，它可以用于解决多种范围查询问题，比如在对数时间内从数组中找到最小值、最大值、总和、最大公约数、最小公倍数等。 数组 A[0,1,…,n−1] 的线段树是一个二叉树，其中每个节点都包含数组的一个子范围 [i…j] 上的聚合信息（最小值、最大值、总和等），其左、右子节点分别包含范围 [i … (i+j)/2]和 [(i+j)/2 + 1, j]上的信息。 class NumArray { public interface Merger<E
线段树模板
02-03
线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的...
线段树-标记永久化技巧
qq_35577488的博客
08-11 924
内容 顾名思义.就是区间修改时,懒标记不下传. 好处 1.码量小，不用写pushdown和pushup 2.在可持久化线段树上应用该技巧能做到区间修改的效果 坏处 1.适用范围有限,只有当求的东西满足区间贡献独立。比如区间加法。 区间最大值就无法标记永久化 2.多标记好像也不适用 模板：洛谷P3372 #include<bits/stdc++.h> using namespace std; #define ll long long #define pii pair<int,int>
--线段树--
m0_59024001的博客
07-04 135
线段树 (Segment Tree) ，一个用来处理 RMQ、RSQ 的数据结构 1. 基本思想 它的思想也是非常简单，比如有一个长度为 8 的区间，我们把它分成两个长度为 4 的区间，然后对于长度为 4 的区间再分割，每个区间记录信息（比如和） ，我们把这些区间当成一棵树上的节点，对于编号为 kkk 的区间 [l,r][l,r][l,r] ，中间点为 mid=⌊l+r2⌋mid=\lfloor \dfrac{l+r}{2} \rfloormid=⌊2l+r​⌋ ，子节点有编号为 2k2k2k 的区间 [l
【YbtOJ 线段树 - 1】求区间和
CW.
07-12 246
求区间和 题目 给定一数列，规定有两种操作，一是修改某个元素，二是求区间的连续和 输入 输出 对于每个询问输出对应的答案 输入样例 10 20 0 1 10 1 1 4 0 6 6 1 4 10 1 8 9 1 4 9 0 10 2 1 1 8 0 2 10 1 3 9 0 7 8 0 3 10 0 1 1 1 3 8 1 6 9 0 5 5 1 1 8 0 4 2 1 2 8 0 1 1 输出样例 10 6 0 6 16 6 24 14 50 41 解题思路 我们这题用的是线段树，没啥好说的
线段树 区间更新模板
weixin_30851867的博客
06-05 66
一个带区间修改的线段树求和模板： int MAXN = 100005; ll a[100005<<2],ans,p; struct Tree { ll l,r; ll sum,add,mul; } tree[100005<<2]; void pushdown(int tr,int len) { if(len==1) ...
线段树区间更新模板
生成猫
08-13 225
最大的遗憾是没写区间乘法的= = int b[100001 int lazy[100001 void pushup(int rt) {     b[rt]=b[rt } void pushdown(int rt,int len) {     if(lazy[rt])     {         lazy[rt         lazy[rt         b
线段树单点，和区间更新模板
a1046765624的博客
03-13 208
描述上回说到：小Hi给小Ho出了这样一道问题：假设整个货架上从左到右摆放了N种商品，并且依次标号为1到N，每次小Hi都给出一段区间[L, R]，小Ho要做的是选出标号在这个区间内的所有商品重量最轻的一种，并且告诉小Hi这个商品的重量。但是在这个过程中，可能会因为其他人的各种行为，对某些位置上的商品的重量产生改变（如更换了其他种类的商品）。小Ho提出了两种非常简单的方法，但是都不能完美的解决。那么这...
线段树--区间更新，区间查询模板（懒标记）
点点滴滴
10-28 233
在线段树中会遇到区间更新的情况，例如 在区间求和问题中，令[a,b]区间内的值全部加c，若此时再采用单点更新的方法，就会耗费大量时间，这个时候就要用到懒标记来进行区间更新了。 设当前结点对应区间[l, r]，待更新区间[a, b] 当 a ≤ l ≤ r ≤ b，即 [l, r]∈[a,b]时，不再向下更新，仅更新当前结点，并在该结点加上懒标记，当必须得更新/查询该...
线段树单点|区间更新模板
KEMNHAN的博客
08-10 178
#include&lt;bits/stdc++.h&gt; using namespace std; #define mem(a,b) memset(a,b,sizeof(a)) #define inf 0x3f3f3f3f typedef long long ll; const int maxn=50010; int a[maxn],ans[maxn],lazy[maxn]; void pu...
(模板)线段树(单点更新,区间更新)模板
alex1997222的博客
04-21 208
单点更新 #include <iostream> using namespace std; const int MAX_N = 10010; int s[4*MAX_N]; void up(int p){ s[p] = s[p*2] + s[p*2+1]; } void modify(int p,int l,int r,int x,int v){ //x为要修改...
树状数组模板区间更新 区间询问
Lawrence_Jang
10-09 7902
14、树状数组 （1）、单点增减+区间求和 思路：C[x]表示该点的元素:sum(x)=C[1]+C[2]+……C[x] int arr[MAXN]; inline int sum(int x){int res=0;while(x)res+=arr[x],x-=lowbit(x);return res;} inline void add(int x,int n){while(x<MAXN)a
线段树--区间更新
SSimpLe_Y的博客
05-24 396
按区间build树，就是为了说明一下向下更新。 #include #include #include using namespace std; const int maxn = 100010; int sum[maxn*4]; int add[maxn*4]; void PushUp(int rt) { sum[rt] = sum[rt*2] + sum[rt*2+1]; } void
线段树详解：区间最小值维护模板
"线段树的学习笔记，个人整理模板，包括区间最小值的维护方法" 线段树是一种数据结构，主要用于高效地处理动态区间查询和更新问题。它将一个区间（通常是一维数组或序列）通过分治策略进行划分，每个划分的节点存储...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值