数据结构——线段树学习笔记

已于 2022-07-10 21:59:31 修改
阅读量367 收藏
点赞数 1
文章标签： 数据结构 学习 算法 c++ 线段树
于 2022-07-10 21:53:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41247488/article/details/125637190
版权

如果对线段树还没有了解，建议先阅读这一篇文章

线段树进阶练习

P1253 [yLOI2018] 扶苏的问题

P1253 [yLOI2018] 扶苏的问题
比普通的线段树多了一个覆盖操作，针对这个问题，我们可以设定三个懒惰标记，分别表示当前位置需要加多少，需不需要被覆盖（也可以不要，如果将不用覆盖的区间的需要被覆盖成的数字设为一个不可能出现的也可以）和需要被覆盖成的数字。
由于出现了覆盖和加法两种情况， p u s h _ d o w n push\_down push_down 函数需要进行一些改动：

void push_down(long long i)
{
	if(tre[i].chan){//覆盖操作
		tre[i*2].sum=(tre[i*2].r-tre[i*2].l+1)*tre[i].change;
		tre[i*2].Max=tre[i].change;
		tre[i*2].chan=true;
		tre[i*2].change=tre[i].change;
		tre[i*2].laz=0;//由于左子树被覆盖，原来不管加了多少，都会被覆盖为同一个数，不能再加了
		tre[i*2+1].sum=(tre[i*2+1].r-tre[i*2+1].l+1)*tre[i].change;
		tre[i*2+1].Max=tre[i].change;
		tre[i*2+1].chan=true;
		tre[i*2+1].change=tre[i].change;
		tre[i*2+1].laz=0;//由于右子树被覆盖，原来不管加了多少，都会被覆盖为同一个数，不能再加了
		tre[i].chan=false;
		tre[i].change=0;
	}
	if(tre[i].laz!=0){//常规加法懒惰标记下推操作
		tre[i*2].laz+=tre[i].laz;
		tre[i*2].sum=tre[i*2].sum+tre[i].laz*(tre[i*2].r-tre[i*2].l+1);
		tre[i*2].Max+=tre[i].laz;
		tre[i*2+1].laz+=tre[i].laz;
		tre[i*2+1].sum=tre[i*2+1].sum+tre[i].laz*(tre[i*2+1].r-tre[i*2+1].l+1);
		tre[i*2+1].Max+=tre[i].laz;
		tre[i].laz=0;
	}
	return;
}

区间覆盖操作：

void cover(long long i,long long l,long long r,long long num)
{
	if(tre[i].l>=l&&tre[i].r<=r){//当前子树已经完全包括在了所要改变的区间里
		//覆盖并标记
		tre[i].laz=0;
		tre[i].sum=num*(tre[i].r-tre[i].l+1);
		tre[i].Max=num;
		tre[i].chan=true;
		tre[i].change=num;
		return;
	}
	push_down(i);
	if(tre[i*2].r>=l)
		cover(i*2,l,r,num);
	if(tre[i*2+1].l<=r)
		cover(i*2+1,l,r,num);
	//更新
	tre[i].sum=tre[i*2].sum+tre[i*2+1].sum;
	tre[i].Max=max(tre[i*2].Max,tre[i*2+1].Max);
	return;
}
完整代码
#include<bits/stdc++.h>
using namespace std;
struct node{
	bool chan;
	long long l,r,sum,laz,change,Max;
} tre[5000000];
long long n,t,a[1000010],a_1,coun;
void setup(long long i,long long l,long long r)
{
	tre[i].l=l;
	tre[i].r=r;
	tre[i].chan=false;
	if(l==r){
		tre[i].sum=a[l];
		tre[i].Max=a[l];
		return;
	}
	long long mid=((l+r)>>1);
	setup(i*2,l,mid);
	setup(i*2+1,mid+1,r);
	tre[i].sum=tre[i*2].sum+tre[i*2+1].sum;
	tre[i].Max=max(tre[i*2].Max,tre[i*2+1].Max);
	return;
}
void push_down(long long i)
{
	if(tre[i].chan){
		tre[i*2].sum=(tre[i*2].r-tre[i*2].l+1)*tre[i].change;
		tre[i*2].Max=tre[i].change;
		tre[i*2].chan=true;
		tre[i*2].change=tre[i].change;
		tre[i*2].laz=0;
		tre[i*2+1].sum=(tre[i*2+1].r-tre[i*2+1].l+1)*tre[i].change;
		tre[i*2+1].Max=tre[i].change;
		tre[i*2+1].chan=true;
		tre[i*2+1].change=tre[i].change;
		tre[i*2+1].laz=0;
		tre[i].chan=false;
		tre[i].change=0;
	}
	if(tre[i].laz!=0){
		tre[i*2].laz+=tre[i].laz;
		tre[i*2].sum=tre[i*2].sum+tre[i].laz*(tre[i*2].r-tre[i*2].l+1);
		tre[i*2].Max+=tre[i].laz;
		tre[i*2+1].laz+=tre[i].laz;
		tre[i*2+1].sum=tre[i*2+1].sum+tre[i].laz*(tre[i*2+1].r-tre[i*2+1].l+1);
		tre[i*2+1].Max+=tre[i].laz;
		tre[i].laz=0;
	}
	return;
}
void add(long long i,long long l,long long r,long long num)
{
	if(tre[i].l>=l&&tre[i].r<=r){
		tre[i].sum=tre[i].sum+num*(tre[i].r-tre[i].l+1);
		tre[i].laz+=num;
		tre[i].Max+=num;
		return;
	}
	push_down(i);
	if(tre[i*2].r>=l)
		add(i*2,l,r,num);
	if(tre[i*2+1].l<=r)
		add(i*2+1,l,r,num);
	tre[i].sum=tre[i*2].sum+tre[i*2+1].sum;
	tre[i].Max=max(tre[i*2].Max,tre[i*2+1].Max);
	return;
}
void cover(long long i,long long l,long long r,long long num)
{
	if(tre[i].l>=l&&tre[i].r<=r){
		tre[i].laz=0;
		tre[i].sum=num*(tre[i].r-tre[i].l+1);
		tre[i].Max=num;
		tre[i].chan=true;
		tre[i].change=num;
		return;
	}
	push_down(i);
	if(tre[i*2].r>=l)
		cover(i*2,l,r,num);
	if(tre[i*2+1].l<=r)
		cover(i*2+1,l,r,num);
	tre[i].sum=tre[i*2].sum+tre[i*2+1].sum;
	tre[i].Max=max(tre[i*2].Max,tre[i*2+1].Max);
	return;
}
long long ask_max(long long i,long long l,long long r)
{
	if(tre[i].l>=l&&tre[i].r<=r)
		return tre[i].Max;
	push_down(i);
	long long ans=-1e15;
	if(tre[i*2].r>=l)
		ans=max(ans,ask_max(i*2,l,r));
	if(tre[i*2+1].l<=r)
		ans=max(ans,ask_max(i*2+1,l,r));
	return ans;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin>>n>>t;
	for(int i=1;i<=n;i++)
		cin>>a[i];
	setup(1,1,n);
	for(int i=1;i<=t;i++){
		long long q,l,r,x;
		cin>>q;
		if(q==1){
			cin>>l>>r>>x;
			cover(1,l,r,x);
		}
		else if(q==2){
			cin>>l>>r>>x;
			add(1,l,r,x);
		}
		else{
			cin>>l>>r;
			cout<<ask_max(1,l,r)<<endl;
		}
	}
	return 0;
}

可能大家都会有一个疑问：为什么 p u s h _ d o w n push\_down push_down 函数一定是先将 覆 盖 懒 惰 标 记 覆盖懒惰标记 覆盖懒惰标记 下推，再推 加 法 懒 惰 标 记 加法懒惰标记 加法懒惰标记，先后顺序不会有问题吗？，接下来，我们就来分析一下：
对于每个位置，只有当两种懒惰标记都有，才可能出现先后顺序的问题。那么如果又一个节点同时出现了两种懒惰标记，只有如下两种情况：

  1. 原来有 覆 盖 懒 惰 标 记 覆盖懒惰标记 覆盖懒惰标记，又被放上了 加 法 懒 惰 标 记 加法懒惰标记 加法懒惰标记（使这种情况出现的两种可能：1.一个节点原有 覆 盖 懒 惰 标 记 覆盖懒惰标记 覆盖懒惰标记，在 p u s h _ d o w n push\_down push_down 后又被放上了一个 加 法 懒 惰 标 记 加法懒惰标记 加法懒惰标记；2.一个节点原有 覆 盖 懒 惰 标 记 覆盖懒惰标记 覆盖懒惰标记 ，在 a d d add add 函数递归到底后又被放上了一个 加 法 懒 惰 标 记 加法懒惰标记 加法懒惰标记；），这种情况下，就是应该先进行 覆 盖 懒 惰 标 记 覆盖懒惰标记 覆盖懒惰标记 的下推，再进行 加 法 懒 惰 标 记 加法懒惰标记 加法懒惰标记 的下推，嗯，没问题。
  2. 原来有 加 法 懒 惰 标 记 加法懒惰标记 加法懒惰标记，又被放上了 覆 盖 懒 惰 标 记 覆盖懒惰标记 覆盖懒惰标记。使这种情况出现的两种可能：1.一个节点原有 加 法 懒 惰 标 记 加法懒惰标记 加法懒惰标记，在 p u s h _ d o w n push\_down push_down 后又被放上了一个 覆 盖 懒 惰 标 记 覆盖懒惰标记 覆盖懒惰标记，但这种情况实际上 加 法 懒 惰 标 记 加法懒惰标记 加法懒惰标记已经没有用处了，所以这种节点的 加 法 懒 惰 标 记 加法懒惰标记 加法懒惰标记 在 p u s h _ d o w n push\_down push_down 后已经被清零了；2.一个节点原有 加 法 懒 惰 标 记 加法懒惰标记 加法懒惰标记，在 c o v e r cover cover 函数递归到底后又被放上了一个 覆 盖 懒 惰 标 记 覆盖懒惰标记 覆盖懒惰标记，但这种情况实际上 加 法 懒 惰 标 记 加法懒惰标记 加法懒惰标记 已经没有用处了，所以这种节点的 加 法 懒 惰 标 记 加法懒惰标记 加法懒惰标记 在 c o v e r cover cover 后已经被清零；

综上，如果一个节点的两种懒惰标记都不为零，则一定是先下推 覆 盖 懒 惰 标 记 覆盖懒惰标记 覆盖懒惰标记 再下推 加 法 懒 惰 标 记 加法懒惰标记 加法懒惰标记。

P8024 [ONTAK2015] Stumilowy sad

P8024 [ONTAK2015] Stumilowy sad

先来分析一下操作

  • 1 l r c：将第 l l l 片区域到第 r r r 片区域内的所有树的高度拔高 c c c 个单位。
  • 2 l r h：将一把刀固定在高度为 h h h 的空中，对第 l l l 片区域到第 r r r 片区域内的所有树进行砍伐。
  • 3 l r h：往第 l l l 片区域到第 r r r 片区域内的每个区域种上一棵高度为 h h h 的树。
  • 4 l r：查询第 l l l 片区域到第 r r r 片区域内最高的树的高度。

我们发现，由于查询只对区间内区域内最大值的最大值进行查询，并且不管什么操作，都不可能让原来区域内不是最大值的数值变得比最大值更大，所以对于每个区域，只维护最大值即可，所以，操作就变为了（假设初始第 i i i 片区域所种的树的高度为 A i A_i Ai​）：

  • 1 l r c：将第 l l l 片区域到第 r r r 片区域内的所有数加上 c c c 区间加
  • 2 l r h：对于所有的 i ∈ [ l , r ] i\in[l,r] i∈[l,r]，将 A i A_i Ai​ 变成 min ⁡ ( A i , h ) \min(A_i,h) min(Ai​,h) 区间取 min ⁡ \min min
  • 3 l r h：对于所有的 i ∈ [ l , r ] i\in[l,r] i∈[l,r]，将 A i A_i Ai​ 变成 min ⁡ ( A i , h ) \min(A_i,h) min(Ai​,h) 区间取 max ⁡ \max max
  • 4 l r：对于所有的 i ∈ [ l , r ] i\in[l,r] i∈[l,r]，求 A i A_i Ai​ 的最大值 区间求最大值

大家可以参考上一题的方法尝试完成，实在做不出来，可以参考下面代码：

完整代码
#include<bits/stdc++.h>
using namespace std;
struct node{
	long long l,r,laz,cover,Max,Min;
	bool change;
} tre[2000010];
long long n,t,input[500010];
void setup(long long i,long long l,long long r)
{
	tre[i].l=l;
	tre[i].r=r;
	if(l==r){
		tre[i].Max=input[l];
		tre[i].Min=input[l];
		return;
	}
	long long mid=((l+r)>>1);
	setup(i*2,l,mid);
	setup(i*2+1,mid+1,r);
	tre[i].Max=max(tre[i*2].Max,tre[i*2+1].Max);
	tre[i].Min=min(tre[i*2].Min,tre[i*2+1].Min);
	return;
}
void push_d(long long i)
{
	if(tre[i].change){
		tre[i*2].Max=tre[i].cover;
		tre[i*2+1].Max=tre[i].cover;
		tre[i*2].Min=tre[i].cover;
		tre[i*2+1].Min=tre[i].cover;
		tre[i*2].cover=tre[i].cover;
		tre[i*2+1].cover=tre[i].cover;
		tre[i*2].change=true;
		tre[i*2+1].change=true;
		tre[i*2].laz=0;
		tre[i*2+1].laz=0;
		tre[i].cover=0;
		tre[i].change=false;
	}
	if(tre[i].laz){
		tre[i*2].Max+=tre[i].laz;
		tre[i*2].Min+=tre[i].laz;
		tre[i*2+1].Min+=tre[i].laz;
		tre[i*2+1].Max+=tre[i].laz;
		tre[i*2].laz+=tre[i].laz;
		tre[i*2+1].laz+=tre[i].laz;
		tre[i].laz=0;
	}
	return;
}
void add(long long i,long long l,long long r,long long num)
{
	if(tre[i].l>=l&&tre[i].r<=r){
		tre[i].Max+=num;
		tre[i].Min+=num;
		tre[i].laz+=num;
		return;
	}
	push_d(i);
	if(tre[i*2].r>=l)
		add(i*2,l,r,num);
	if(tre[i*2+1].l<=r)
		add(i*2+1,l,r,num);
	tre[i].Max=max(tre[i*2].Max,tre[i*2+1].Max);
	tre[i].Min=min(tre[i*2].Min,tre[i*2+1].Min);
	return;
}
void cut_tree(long long i,long long l,long long r,long long num)
{
	if(tre[i].l>=l&&tre[i].r<=r){
		if(tre[i].Min>=num){
			tre[i].Max=num;
			tre[i].Min=num;
			tre[i].cover=num;
			tre[i].change=true;
			tre[i].laz=0;
			return;
		}
		if(tre[i].Max<=num)
			return;
	}
	push_d(i);
	if(tre[i*2].r>=l)
		cut_tree(i*2,l,r,num);
	if(tre[i*2+1].l<=r)
		cut_tree(i*2+1,l,r,num);
	tre[i].Max=max(tre[i*2].Max,tre[i*2+1].Max);
	tre[i].Min=min(tre[i*2].Min,tre[i*2+1].Min);
	return;
}
void grow_tree(long long i,long long l,long long r,long long num)
{
	if(tre[i].l>=l&&tre[i].r<=r){
		if(tre[i].Max<=num){
			tre[i].Min=num;
			tre[i].Max=num;
			tre[i].cover=num;
			tre[i].change=true;
			tre[i].laz=0;
			return; 
		}
		if(tre[i].Min>=num)
			return; 
	}
	push_d(i);
	if(tre[i*2].r>=l)
		grow_tree(i*2,l,r,num);
	if(tre[i*2+1].l<=r)
		grow_tree(i*2+1,l,r,num);
	tre[i].Max=max(tre[i*2].Max,tre[i*2+1].Max);
	tre[i].Min=min(tre[i*2].Min,tre[i*2+1].Min);
	return;
}
long long ask(long long i,long long l,long long r)
{
	if(tre[i].l>=l&&tre[i].r<=r)
		return tre[i].Max;
	long long value=-1e15;
	push_d(i);
	if(tre[i*2].r>=l)
		value=max(value,ask(i*2,l,r));
	if(tre[i*2+1].l<=r)
		value=max(value,ask(i*2+1,l,r));
	return value;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin>>n>>t;
	for(int i=1;i<=n;i++)
		cin>>input[i];
	setup(1,1,n);
	for(int i=1;i<=t;i++){
		long long q,l,r,num;
		cin>>q;
		if(q==1){
			cin>>l>>r>>num;
			add(1,l,r,num);
		}
		else if(q==2){
			cin>>l>>r>>num;
			cut_tree(1,l,r,num);
		}
		else if(q==3){
			cin>>l>>r>>num;
			grow_tree(1,l,r,num);
		}
		else{
			cin>>l>>r;
			cout<<ask(1,l,r)<<endl;
		}
	}
	return 0;
}

P1438 无聊的数列

P1438 无聊的数列
首先分析一下操作：

  • 1 l r K D：给出一个长度等于 r − l + 1 r-l+1 r−l+1 的等差数列，首项为 K K K，公差为 D D D，并将它对应加到 [ l , r ] [l,r] [l,r] 范围中的每一个数上。即：令 a l = a l + K , a l + 1 = a l + 1 + K + D … a r = a r + K + ( r − l ) × D a_l=a_l+K,a_{l+1}=a_{l+1}+K+D\ldots a_r=a_r+K+(r-l) \times D al​=al​+K,al+1​=al+1​+K+D…ar​=ar​+K+(r−l)×D。
  • 2 p：询问序列的第 p p p 个数的值 a p a_p ap​。

题目对我们还挺仁慈的，看一下操作一，你看到了什么？首项为K，公差为D，你又想到了什么？差分？没毛病，就是差分！
原数列的差分数组为 0 , 0 , 0 , . . . 0,0,0,... 0,0,0,...，如果使用操作一1 1 4 1 1，则这个差分就会变成： 1 , 1 , 1 , 1 , 0 , . . . 1,1,1,1,0,... 1,1,1,1,0,...(首项变的差分数组加上 K K K，后边一直到区间末尾，差分数组全部加上 D D D)
如果询问第 p p p 个数，按照差分的性质，只要将前 p p p 个位置的数字加起来即可

完整代码
#include<bits/stdc++.h>
using namespace std;
struct node{
	long long l,r,sum,laz;
} tre[400010];
long long s[100010],a[100010],n,t;
void setup(long long i,long long l,long long r)
{
	tre[i].l=l;
	tre[i].r=r;
	tre[i].laz=0;
	if(l==r){
		tre[i].sum=a[l];
		return;
	}
	long long mid=((l+r)>>1);
	setup(i*2,l,mid);
	setup(i*2+1,mid+1,r);
	tre[i].sum=tre[i*2].sum+tre[i*2+1].sum;
	return;
}
void push_d(long long i)
{
	if(tre[i].laz){
		tre[i*2].laz+=tre[i].laz;
		tre[i*2+1].laz+=tre[i].laz;
		tre[i*2].sum=tre[i*2].sum+tre[i].laz*(tre[i*2].r-tre[i*2].l+1);
		tre[i*2+1].sum=tre[i*2+1].sum+tre[i].laz*(tre[i*2+1].r-tre[i*2+1].l+1);
		tre[i].laz=0;
	}
	return;
}
void add(long long i,long long l,long long r,long long num)
{
	if(l<=tre[i].l&&tre[i].r<=r){
		tre[i].sum=tre[i].sum+(tre[i].r-tre[i].l+1)*num;
		tre[i].laz+=num;
		return;
	}
	push_d(i);
	if(tre[i*2].r>=l)
		add(i*2,l,r,num);
	if(tre[i*2+1].l<=r)
		add(i*2+1,l,r,num);
	tre[i].sum=tre[i*2].sum+tre[i*2+1].sum;
	return;
}
long long ask(long long i,long long l,long long r)
{
	if(l<=tre[i].l&&tre[i].r<=r)
		return tre[i].sum;
	push_d(i);
	long long ans=0;
	if(tre[i*2].r>=l)
		ans+=ask(i*2,l,r);
	if(tre[i*2+1].l<=r)
		ans+=ask(i*2+1,l,r);
	return ans;
}
int main()
{
	cin>>n>>t;
	for(int i=1;i<=n;i++)
		cin>>a[i];
	for(int i=n-1;i>0;i--)
		a[i+1]=a[i+1]-a[i];
	setup(1,1,n);
	for(int i=1;i<=t;i++){
		long long q,l,r,num1,num2;
		cin>>q;
		if(q==1){
			cin>>l>>r>>num1>>num2;
			add(1,l,l,num1);
			if(l+1<=r)
				add(1,l+1,r,num2);
			if(r<n)
				add(1,r+1,r+1,-(num1+num2*(r-l)));
		}
		else{
			cin>>l;
			cout<<ask(1,1,l)<<endl;
		}
	}
}

P6373 「StOI-1」IOI计数

P6373 「StOI-1」IOI计数
我们可以发现，操作2所做的询问，实际上就是在询问字符串 S S S 中有多少字串为 I O I IOI IOI。那就先来考虑给定一个字符串，如何统计有多少个为 I O I IOI IOI 的子串。如果将两个字符串合并起来，怎么得到 I O I IOI IOI 子串的个数？考虑使用加法和乘法原理。首先，至少，两边出现过的 I O I IOI IOI 子串，合并之后依然会有，所以， 目 前 字 符 串 I O I 子 串 个 数 + = ( 左 区 间 I O I 子 串 个 数 + 右 区 间 I O I 子 串 个 数 ) 目前字符串IOI子串个数+=(左区间IOI子串个数+右区间IOI子串个数) 目前字符串IOI子串个数+=(左区间IOI子串个数+右区间IOI子串个数)，接下来，考虑将两区间拼接起来后又得到的 I O I IOI IOI 子串个数加上。分类讨论一下，有以下几种情况：

  • 左区间存在 I O IO IO 子串，并且右区间存在 I I I 子串，这种情况所得到的子串个数为 左 区 间 I O 子 串 个 数 × 右 区 间 I 子 串 个 数 左区间IO子串个数\times右区间I子串个数 左区间IO子串个数×右区间I子串个数
  • 左区间存在 I I I 子串，并且右区间存在 O I OI OI 子串，这种情况所得到的子串个数为 左 区 间 I 子 串 个 数 × 右 区 间 O I 子 串 个 数 左区间I子串个数\times右区间OI子串个数 左区间I子串个数×右区间OI子串个数

∴ 目 前 字 符 串 I O I 子 串 个 数 + = ( 左 区 间 I O 子 串 个 数 × 右 区 间 I 子 串 个 数 + 左 区 间 I 子 串 个 数 × 右 区 间 O I 子 串 个 数 ) \therefore目前字符串IOI子串个数+=(左区间IO子串个数\times右区间I子串个数+左区间I子串个数\times右区间OI子串个数) ∴目前字符串IOI子串个数+=(左区间IO子串个数×右区间I子串个数+左区间I子串个数×右区间OI子串个数)
∴ 目 前 字 符 串 I O I 子 串 个 数 = 左 区 间 I O I 子 串 个 数 + 右 区 间 I O I 子 串 个 数 + 左 区 间 个 数 I O 子 串 × 右 区 间 I 子 串 个 数 + 左 区 间 I 子 串 个 数 × 右 区 间 O I 子 串 个 数 \therefore目前字符串IOI子串个数=左区间IOI子串个数+右区间IOI子串个数+左区间个数IO子串\times右区间I子串个数+左区间I子串个数\times右区间OI子串个数 ∴目前字符串IOI子串个数=左区间IOI子串个数+右区间IOI子串个数+左区间个数IO子串×右区间I子串个数+左区间I子串个数×右区间OI子串个数
这样就能写线段树了！但是在计算过程中，也使用过左右子串的 I , I O , O I , O I,IO,OI,O I,IO,OI,O 子串个数，所以，也需要对每个子串的这些子串的个数进行维护：

  • 目 前 字 符 串 I 子 串 个 数 = 左 区 间 I 子 串 个 数 + 右 区 间 I 子 串 个 数 目前字符串I子串个数=左区间I子串个数+右区间I子串个数 目前字符串I子串个数=左区间I子串个数+右区间I子串个数
  • 目 前 字 符 串 O 子 串 个 数 = 左 区 间 O 子 串 个 数 + 右 区 间 O 子 串 个 数 目前字符串O子串个数=左区间O子串个数+右区间O子串个数 目前字符串O子串个数=左区间O子串个数+右区间O子串个数
  • 目 前 字 符 串 I O 子 串 个 数 = 左 区 间 I 子 串 个 数 × 右 区 间 O 子 串 个 数 目前字符串IO子串个数=左区间I子串个数\times右区间O子串个数 目前字符串IO子串个数=左区间I子串个数×右区间O子串个数
  • 目 前 字 符 串 O I 子 串 个 数 = 左 区 间 O 子 串 个 数 × 右 区 间 I 子 串 个 数 目前字符串OI子串个数=左区间O子串个数\times右区间I子串个数 目前字符串OI子串个数=左区间O子串个数×右区间I子串个数

这样，就可以用线段树做了。而操作一就算一个简单的单点修改，有了上面的更新方法，也可以轻松解决了。

完整代码
#include<bits/stdc++.h>
using namespace std;
struct node{
	long long l,r,sum_i,sum_o,sum_io,sum_oi,sum_ioi;
} tre[2000100];
long long n,t,a[500010];
char c;
void push_up(long long i)
{
	tre[i].sum_i=tre[i*2].sum_i+tre[i*2+1].sum_i;
	tre[i].sum_o=tre[i*2].sum_o+tre[i*2+1].sum_o;
	tre[i].sum_oi=tre[i*2].sum_oi+tre[i*2+1].sum_oi+tre[i*2].sum_o*tre[i*2+1].sum_i;
	tre[i].sum_io=tre[i*2].sum_io+tre[i*2+1].sum_io+tre[i*2].sum_i*tre[i*2+1].sum_o;
	tre[i].sum_ioi=tre[i*2].sum_ioi+tre[i*2+1].sum_ioi+tre[i*2].sum_i*tre[i*2+1].sum_oi+tre[i*2].sum_io*tre[i*2+1].sum_i;
	return;
}
void setup(long long i,long long l,long long r)
{
	tre[i].l=l;
	tre[i].r=r;
	if(l==r){
		if(a[l]==1)
			tre[i].sum_i++;
		else if(a[l]==2)
			tre[i].sum_o++;
		return;
	}
	long long mid=((l+r)>>1);
	setup(i*2,l,mid);
	setup(i*2+1,mid+1,r);
	push_up(i);
}
void change(long long i,long long p,long long change_to)
{
	if(tre[i].l==tre[i].r){
		if(change_to==1){
			if(tre[i].sum_i==0)
				tre[i].sum_i++;
			if(tre[i].sum_o!=0)
				tre[i].sum_o--;
		}
		else{
			if(tre[i].sum_o==0)
				tre[i].sum_o++;
			if(tre[i].sum_i!=0)
				tre[i].sum_i--;
		}
		return;
	}
	if(tre[i*2].r>=p)
		change(i*2,p,change_to);
	if(tre[i*2+1].l<=p)
		change(i*2+1,p,change_to);
	push_up(i);
}
node ask(long long i,long long l,long long r)
{
	if(l<=tre[i].l&&tre[i].r<=r)
		return tre[i];
	node ans,ans1;
	if(tre[i*2].r>=l){
		ans1=ask(i*2,l,r);
		if(tre[i*2+1].l<=r){
			node ans2=ask(i*2+1,l,r);
			ans.sum_i=ans1.sum_i+ans2.sum_i;
			ans.sum_o=ans1.sum_o+ans2.sum_o;
			ans.sum_io=ans1.sum_io+ans2.sum_io+ans1.sum_i*ans2.sum_o;
			ans.sum_oi=ans1.sum_oi+ans2.sum_oi+ans1.sum_o*ans2.sum_i;
			ans.sum_ioi=ans1.sum_ioi+ans2.sum_ioi+ans1.sum_i*ans2.sum_oi+ans1.sum_io*ans2.sum_i; 
		}
		else
			ans=ans1;
	}
	else if(tre[i*2+1].l<=r)
		ans=ask(i*2+1,l,r);
	return ans;
}
int main()
{
	cin>>n>>t;
	for(int i=1;i<=n;i++){
		cin>>c;
		if(c=='I')
			a[i]=1;
		else
			a[i]=2;
	}
	setup(1,1,n);
	for(int i=1;i<=t;i++){
		long long q,l,r,num;
		cin>>q;
		if(q==1){
			cin>>l>>c;
			if(c=='I')
				change(1,l,1);
			else
				change(1,l,2);
		}
		else{
			cin>>l>>r;
			cout<<ask(1,l,r).sum_ioi<<endl;
		}
	}
}

P4588 [TJOI2018]数学计算

P4588 [TJOI2018]数学计算
我们可以考虑以时间为下标，维护一个数组，支持单点修改（初始状态， A A A 中全部为 1 1 1），第 i i i 次操作就将 A i A_i Ai​ 的值修改为所乘的值，遇到还原操作，要求还原第 p o s pos pos 个操作，那么我们就将 A p o s A_{pos} Apos​ 的值还原为 1 1 1。由于未执行到的操作都未 1 1 1，对答案不会出现影响，只有已近操作过的位置，才对答案有影响，并且所有要求还原的位置也都为 1 1 1，所以答案就是将数组内所有点的数值全部相乘的值（相当于所有操作过，并且未被还原的位置相乘）模上 M M M，熟悉的区间乘，线段树维护即可。

#include<bits/stdc++.h>
using namespace std;
struct node{
	long long l,r,ans;
} tre[400010];
long long Mod,n,m,t,tot,p_t_p[100010],cb[100010];
void setup(long long i,long long l,long long r)
{
	tre[i].l=l;
	tre[i].r=r;
	if(l==r){
		tre[i].ans=1;
		return;
	}
	long long mid=((l+r)>>1);
	setup(i*2,l,mid);
	setup(i*2+1,mid+1,r);
	tre[i].ans=tre[i*2].ans*tre[i*2+1].ans;
	return;
}
void change(long long i,long long p,long long num)
{
	if(tre[i].l==tre[i].r){
		tre[i].ans=num;
		return;
	}
	if(tre[i*2].r>=p)
		change(i*2,p,num);
	else
		change(i*2+1,p,num);
	tre[i].ans=tre[i*2].ans*tre[i*2+1].ans%Mod;
	return;
}
void change_back(long long i,long long p)
{
	if(tre[i].l==tre[i].r){
		tre[i].ans=1;
		return;
	}
	if(tre[i*2].r>=p)
		change_back(i*2,p);
	else
		change_back(i*2+1,p);
	tre[i].ans=tre[i*2].ans*tre[i*2+1].ans%Mod;
	return;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin>>t;
	for(int i=1;i<=t;i++){
		memset(tre,0,sizeof(tre));
		cin>>n>>Mod;
		setup(1,1,n);
		for(int j=1;j<=n;j++){
			long long q,p;
			cin>>q>>p;
			if(q==1){
				change(1,j,p);
				cout<<tre[1].ans<<endl;
			}
			else{
				change_back(1,p);
				cout<<tre[1].ans<<endl;
			}
		}
	}
	return 0;
}

吉老师线段树

此算法来自于区间最值操作与历史最值问题——吉如一（第六篇）
我们可以借助下面这道例题进行学习

例题：P6242 【模板】线段树 3

P6242 【模板】线段树 3
简单来讲，就是让我们进行如下操作：

  • 1 l r k：对于所有的 i ∈ [ l , r ] i\in[l,r] i∈[l,r]，将 A i A_i Ai​ 加上 k k k（ k k k 可以为负数） 区间加
  • 2 l r v：对于所有的 i ∈ [ l , r ] i\in[l,r] i∈[l,r]，将 A i A_i Ai​ 变成 min ⁡ ( A i , v ) \min(A_i,v) min(Ai​,v) 区间取 min ⁡ \min min
  • 3 l r：求 ∑ i = l r A i \sum\limits_{i=l}^{r}A_i i=l∑r​Ai​ 求区间和
  • 4 l r：对于所有的 i ∈ [ l , r ] i\in[l,r] i∈[l,r]，求 A i A_i Ai​ 的最大值 区间求最大值
  • 5 l r：对于所有的 i ∈ [ l , r ] i\in[l,r] i∈[l,r]，求 B i B_i Bi​ 的最大值 求区间历史最大值

其中操作 1 , 3 , 4 1,3,4 1,3,4 对于我们已经是老朋友了，普普通通的线段树就可以搞定了，那怎么做到操作二和五？
先来看操作二：
嗯，也挺熟悉的，仿佛有点像这道题，当时，是给每个区间维护最大值和最小值，然后一直遍历，如果遇到最大值小于等于所要取最小值的数，这个区间便不用改变（直接return），而如果最小值大于等于所要取最小值，就是直接将整个区间进行覆盖。我试着做了一下，太麻烦了主要是都调不对，然后仔细思考并参考了亿下题解，发现可以简单很多，因为这一题不用维护最小值，只有最大值。
所以当一个区间内取 m i n min min 的时候，只要我们将区间分得足够小，就只有两种情况：1.全部不变（区间内最大值小于等于 v v v）；2.只有最大值改变（区间内最大值大于等于 v v v 并且严格次大值小于 v v v）。第一种情况是不用管的，而对于第二种情况，如果我们将每个区间内的数字分为两组，一组为最大值（可能重复），其他的数字就分为另一组（每组对应自己的懒惰标记），就不再需要覆盖操作，只需改变最大值的懒惰标记，将他们都减成需要改变为的数就好了（如将 5 , 5 , 2 5,5,2 5,5,2 覆盖为 3 , 3 , 2 3,3,2 3,3,2 就相当于是将整个区间内所有的最大值都加上一个 − 2 -2 −2）
所以我们只需维护两个懒惰标记，维护一个最大值，并维护最大值个数，再维护一个严格次大值，就可以实现操作二。

再来看操作五：
按照题目本意，就是让我们再另外建一棵树。那如果这样该怎么办？我们可以参考上面的建树方法。但是，再更新的过程中，就需要一些改变。那么假设（注：1. 原 原 原 表示还未改动的;2.下面括号内的东西不一定需要理解，下面有解释）：

  • h i s t o r y _ m a x _ l a z history\_max\_laz history_max_laz 为当前区间内最大值的历史懒惰标记（ 原 n o w _ m a x + 父 节 点 h i s t o r y _ m a x _ l a z = 本 次 更 新 后 的 h i s t o r y _ m a x 原now\_max+父节点history\_max\_laz=本次更新后的history\_max 原now_max+父节点history_max_laz=本次更新后的history_max，且 原 n o w _ m a x _ l a z + 父 节 点 h i s t o r y _ m a x _ l a z = 本 次 更 新 后 的 h i s t o r t _ m a x _ l a z 原now\_max\_laz+父节点history\_max\_laz=本次更新后的histort\_max\_laz 原now_max_laz+父节点history_max_laz=本次更新后的histort_max_laz），
  • h i s t o r y _ u n m a x _ l a z history\_unmax\_laz history_unmax_laz 当前区间内非最大值的历史懒惰标记（ 原 n o w _ u n m a x _ l a z + 父 节 点 h i s t o r y _ u n m a x _ l a z = 本 次 更 新 后 的 h i s t o r y _ u n m a x _ l a z 原now\_unmax\_laz+父节点history\_unmax\_laz=本次更新后的history\_unmax\_laz 原now_unmax_laz+父节点history_unmax_laz=本次更新后的history_unmax_laz ，若父节点的最大值不在该子树内，则 原 n o w _ m a x + 父 节 点 h i s t o r y _ u n m a x _ l a z = 本 次 更 新 后 的 h i s t o r y _ m a x 原now\_max+父节点history\_unmax\_laz=本次更新后的history\_max 原now_max+父节点history_unmax_laz=本次更新后的history_max 且 原 n o w _ m a x _ l a z + 父 节 点 h i s t o r y _ u n m a x _ l a z = 本 次 更 新 后 的 h i s t o r y _ m a x _ l a z 原now\_max\_laz+父节点history\_unmax\_laz=本次更新后的history\_max\_laz 原now_max_laz+父节点history_unmax_laz=本次更新后的history_max_laz），
  • h i s t o r y _ m a x history\_max history_max 为区间内历史出现过的最大值，
  • n o w _ m a x _ l a z now\_max\_laz now_max_laz 为当前区间最大值的懒惰标记，
  • n o w _ u n m a x _ l a z now\_unmax\_laz now_unmax_laz 为当前区间非最大值的懒惰标记，
  • n o w _ m a x now\_max now_max 为当前区间内的最大值，
  • n u m _ o f _ n o w _ m a x num\_of\_now\_max num_of_now_max 为当前区间内最大值的数量，
  • n o w _ m a x _ a d d now\_max\_add now_max_add 为当前区间最大值需要加的数字，
  • n o w _ u n m a x _ a d d now\_unmax\_add now_unmax_add 为当前区间非最大值需要加的数字，
  • h i s t o r y _ m a x _ a d d history\_max\_add history_max_add 为区间内历史最大值所需要加的数字，

更新操作如下：

void update(long long i,long long now_max_add,long long history_max_add,long long now
_unmax_add,long long history_unmax_add)//更新函数
{
	tre[i].sum=(long long)tre[i].sum+now_max_add*tre[i].num_of_now_max+now_unmax_add*(tre[i].r-tre[i].l+1-tre[i].num_of_now_max);//更新和，原来的+最大值的变化+非最大值的变化
	tre[i].history_max=max(tre[i].history_max,tre[i].now_max+history_max_add);//更新区间内历史最大值，注意：此处的now_max未修改
	tre[i].history_max_laz=max(tre[i].history_max_laz,tre[i].now_max_laz+history_max_add);//更新区间内历史最大值的懒惰标记，与当前区间懒惰标记的更新不同，是因为此处所取的是历史最大值，只要是所有出现过的数值中最大的，所以如果当前更新会让数字更小，就可以选择不去进行更新（典型的贪心）
	tre[i].history_unmax_laz=max(tre[i].history_unmax_laz,tre[i].now_unmax_laz+history_unmax_add);//理由同上，至于为什么不需要一起进行更新，是因为一个区间内的历史最大值，不一定要一起进行改动。比如可能是在这一次出现了当前区间内最大值的历史最大值，但又是在下一次出现了当前区间内非最大值的历史最大值，若让两者同时更新，就不能满足所有位置都是历史出现过的至中最大的值了
	tre[i].now_max+=now_max_add;//懒惰标记常规更新
	tre[i].now_max_laz+=now_max_add;//懒惰标记常规更新
	if(tre[i].second_now_max!=(long long)-1000000000)//-1000000000是在建树过程中为防止一个区间内所有数字都重复（无严格次大值），所设置的极限小值
		tre[i].second_now_max+=now_unmax_add;//若有严格次大值，就进行更新
	tre[i].now_unmax_laz+=now_unmax_add;//懒惰标记常规更新
	return;
}

实际上，这样相当于是维护了两棵树，一棵保存当前状态（以 n o w _ now\_ now_ 为开头的），另一棵保存历史状态（以 h i s t o r y _ history\_ history_ 为开头的），但两棵树又有联系：

  1. h i s t o r y history history 树中的所有懒惰标记都是以 n o w now now 树为准的（主要联系），如：
    原 n o w _ m a x + 父 节 点 h i s t o r y _ m a x _ l a z = 本 次 更 新 后 的 h i s t o r y _ m a x 原now\_max+父节点history\_max\_laz=本次更新后的history\_max 原now_max+父节点history_max_laz=本次更新后的history_max
    原 n o w _ m a x _ l a z + 父 节 点 h i s t o r y _ m a x _ l a z = 本 次 更 新 后 的 h i s t o r y _ m a x _ l a z 原now\_max\_laz+父节点history\_max\_laz=本次更新后的history\_max\_laz 原now_max_laz+父节点history_max_laz=本次更新后的history_max_laz
    （以上的“父节点”是因为正在下推）
  2. 两树公用左右起始和终止点（ l , r l,r l,r）

接下来来看 p u s h _ d o w n push\_down push_down 函数：

void push_d(long long i)
{
	long long now_max=max(tre[i*2].now_max,tre[i*2+1].now_max);//注意，不可取 tre[i].now_max，因为当前节点的数据已经更新过，而左右子树还未更新
	if(tre[i*2].now_max==now_max)//分类讨论，如果左子树内有最大值
		update(i*2,tre[i].now_max_laz,tre[i].history_max_laz,tre[i].now_unmax_laz,tre[i].history_unmax_laz);//如果左子树内有该区间最大值,则左子树的最大值就是该区间的最大值
	else//如果左子树内没有最大值
		update(i*2,tre[i].now_unmax_laz,tre[i].history_unmax_laz,tre[i].now_unmax_laz,tre[i].history_unmax_laz);//如果左子树内没有该区间最大值,则左子树的最大值就是该区间的非最大值
	if(tre[i*2+1].now_max==now_max)//分类讨论，如果右子树内有最大值
		update(i*2+1,tre[i].now_max_laz,tre[i].history_max_laz,tre[i].now_unmax_laz,tre[i].history_unmax_laz);//如果右子树内有该区间最大值,则右子树的最大值就是该区间的最大值
	else
		update(i*2+1,tre[i].now_unmax_laz,tre[i].history_unmax_laz,tre[i].now_unmax_laz,tre[i].history_unmax_laz);//如果右子树内没有该区间最大值,则右子树的最大值就是该区间的非最大值
	//清零懒惰标记
	tre[i].history_max_laz=0;
	tre[i].history_unmax_laz=0;
	tre[i].now_max_laz=0;
	tre[i].now_unmax_laz=0;
	return;
}

最后看一下区间合并的操作：

void merge(long long i)
{
	//区间合并常规操作
	tre[i].history_max=max(tre[i*2].history_max,tre[i*2+1].history_max);
	tre[i].now_max=max(tre[i*2].now_max,tre[i*2+1].now_max);
	tre[i].sum=tre[i*2].sum+tre[i*2+1].sum;
	//更新最大值以及其个数
	if(tre[i*2].now_max==tre[i*2+1].now_max){//分类讨论，若左右子树都有该区间的最大值
		tre[i].second_now_max=max(tre[i*2].second_now_max,tre[i*2+1].second_now_max);//严格次大值就是两子树内严格次大值的最大值
		tre[i].num_of_now_max=tre[i*2].num_of_now_max+tre[i*2+1].num_of_now_max;//左右最大值个数之和
	}
	else if(tre[i*2].now_max>tre[i*2+1].now_max){//分类讨论，若最大值在左子树
		tre[i].second_now_max=max(tre[i*2].second_now_max,tre[i*2+1].now_max);//严格次大值就是左子树严格次大值和右子树最大值中的最大值（因为右子树中的最大值一定小于该区间最大值，并且一定是右子树中所有小于该区间最大值的值中的最大值）
		tre[i].num_of_now_max=tre[i*2].num_of_now_max;//全在左子树
	}
	else{
		tre[i].second_now_max=max(tre[i*2].now_max,tre[i*2+1].second_now_max);//严格次大值就是右子树严格次大值和左子树最大值中的最大值（因为左子树中的最大值一定小于该区间最大值，并且一定是左子树中所有小于该区间最大值的值中的最大值）
		tre[i].num_of_now_max=tre[i*2+1].num_of_now_max;//全在右子树
	}
}

剩下的操作就都是普通线段树中的常规操作了。

完整代码

真的难调

#include<bits/stdc++.h>
using namespace std;
struct node{
	long long l,r,sum,history_max,now_max,second_now_max,num_of_now_max,history_max_laz,history_unmax_laz,now_max_laz,now_unmax_laz;
} tre[2000010];
long long n,m,a[500010];
void merge(long long i)
{
	tre[i].history_max=max(tre[i*2].history_max,tre[i*2+1].history_max);
	tre[i].now_max=max(tre[i*2].now_max,tre[i*2+1].now_max);
	tre[i].sum=tre[i*2].sum+tre[i*2+1].sum;
	if(tre[i*2].now_max==tre[i*2+1].now_max){
		tre[i].second_now_max=max(tre[i*2].second_now_max,tre[i*2+1].second_now_max);
		tre[i].num_of_now_max=tre[i*2].num_of_now_max+tre[i*2+1].num_of_now_max;
	}
	else if(tre[i*2].now_max>tre[i*2+1].now_max){
		tre[i].second_now_max=max(tre[i*2].second_now_max,tre[i*2+1].now_max);
		tre[i].num_of_now_max=tre[i*2].num_of_now_max;
	}
	else{
		tre[i].second_now_max=max(tre[i*2].now_max,tre[i*2+1].second_now_max);
		tre[i].num_of_now_max=tre[i*2+1].num_of_now_max;
	}
}
void update(long long i,long long now_max_add,long long history_max_add,long long now_unmax_add,long long history_unmax_add)
{
	tre[i].sum=(long long)tre[i].sum+now_max_add*tre[i].num_of_now_max+now_unmax_add*(tre[i].r-tre[i].l+1-tre[i].num_of_now_max);
	tre[i].history_max=max(tre[i].history_max,tre[i].now_max+history_max_add);
	tre[i].history_max_laz=max(tre[i].history_max_laz,tre[i].now_max_laz+history_max_add);
	tre[i].history_unmax_laz=max(tre[i].history_unmax_laz,tre[i].now_unmax_laz+history_unmax_add);
	tre[i].now_max+=now_max_add;
	tre[i].now_max_laz+=now_max_add;
	if(tre[i].second_now_max!=(long long)-1000000000)
		tre[i].second_now_max+=now_unmax_add;
	tre[i].now_unmax_laz+=now_unmax_add;
	return;
}
void push_d(long long i)
{
	long long now_max=max(tre[i*2].now_max,tre[i*2+1].now_max);
	if(tre[i*2].now_max==now_max)
		update(i*2,tre[i].now_max_laz,tre[i].history_max_laz,tre[i].now_unmax_laz,tre[i].history_unmax_laz);
	else
		update(i*2,tre[i].now_unmax_laz,tre[i].history_unmax_laz,tre[i].now_unmax_laz,tre[i].history_unmax_laz);
	if(tre[i*2+1].now_max==now_max)
		update(i*2+1,tre[i].now_max_laz,tre[i].history_max_laz,tre[i].now_unmax_laz,tre[i].history_unmax_laz);
	else
		update(i*2+1,tre[i].now_unmax_laz,tre[i].history_unmax_laz,tre[i].now_unmax_laz,tre[i].history_unmax_laz);
	tre[i].history_max_laz=0;
	tre[i].history_unmax_laz=0;
	tre[i].now_max_laz=0;
	tre[i].now_unmax_laz=0;
	return;
}
void setup(long long i,long long l,long long r)
{
	tre[i].l=l;
	tre[i].r=r;
	if(l==r){
		tre[i].sum=a[l];
		tre[i].now_max=a[l];
		tre[i].history_max=a[l];
		tre[i].num_of_now_max=1;
		tre[i].second_now_max=(long long)-1000000000;
		return;
	}
	long long mid=((l+r)>>1);
	setup(i*2,l,mid);
	setup(i*2+1,mid+1,r);
	merge(i);
	return;
}
void change_add(long long i,long long l,long long r,long long num)
{
	if(tre[i].l>=l&&tre[i].r<=r){
		update(i,num,num,num,num);
		return;
	}
	push_d(i);
	if(tre[i*2].r>=l)
		change_add(i*2,l,r,num);
	if(tre[i*2+1].l<=r)
		change_add(i*2+1,l,r,num);
	merge(i);
	return;
}
void change_min(long long i,long long l,long long r,long long num)
{
	if(tre[i].now_max<=num)
		return;
	if(tre[i].l>=l&&tre[i].r<=r&&tre[i].second_now_max<num){
		update(i,num-tre[i].now_max,num-tre[i].now_max,0,0);
		return;
	}
	push_d(i);
	if(tre[i*2].r>=l)
		change_min(i*2,l,r,num);
	if(tre[i*2+1].l<=r)
		change_min(i*2+1,l,r,num);
	merge(i);
	return;
}
long long ask_sum(long long i,long long l,long long r)
{
	if(tre[i].l>=l&&tre[i].r<=r)
		return tre[i].sum;
	push_d(i);
	long long value=0;
	if(tre[i*2].r>=l)
		value+=ask_sum(i*2,l,r);
	if(tre[i*2+1].l<=r)
		value+=ask_sum(i*2+1,l,r);
	return value;
}
long long ask_now_max(long long i,long long l,long long r)
{
	if(tre[i].l>=l&&tre[i].r<=r)
		return tre[i].now_max;
	push_d(i);
	long long value=(long long)-1000000000;
	if(tre[i*2].r>=l)
		value=max(value,ask_now_max(i*2,l,r));
	if(tre[i*2+1].l<=r)
		value=max(value,ask_now_max(i*2+1,l,r));
	return value;
}
long long ask_history_max(long long i,long long l,long long r)
{
	if(tre[i].l>=l&&tre[i].r<=r)
		return tre[i].history_max;
	push_d(i);
	long long value=(long long)-1000000000;
	if(tre[i*2].r>=l)
		value=max(value,ask_history_max(i*2,l,r));
	if(tre[i*2+1].l<=r)
		value=max(value,ask_history_max(i*2+1,l,r));
	return value;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		cin>>a[i];
	setup(1,1,n);
	for(int i=1;i<=m;i++){
		long long q,l,r,num;
		cin>>q>>l>>r;
		if(q==1){
			cin>>num;
			change_add(1,l,r,num);
		}
		else if(q==2){
			cin>>num;
			change_min(1,l,r,num);
		}
		else if(q==3)
			cout<<ask_sum(1,l,r)<<"\n";
		else if(q==4)
			cout<<ask_now_max(1,l,r)<<"\n";
		else
			cout<<ask_history_max(1,l,r)<<"\n";
	}
	return 0;
}

可持久化线段树（主席树）

还没学会，正在学

ssl_wtj
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线段树学习笔记（个人整理模板）
12-25
个人线段树学习整理
数据结构的半夜——线段树学习笔记2:离散化
qq_37753448的博客
12-29 99
今晚完成了kuanbin带你飞的第四道例题，一道运用离散化思想的题目 这里就来总结归纳这道例题 D-Mayor’s posters Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 80590 Accepted: 23189 Description The citizens of Bytetown, AB,...
数据结构的半夜——线段树学习笔记1
weixin_30572613的博客
01-22 89
说过以后写blog要严肃点，我现在就严肃地修改一下，删冗余，精简语言 线段树,英文Segment Tree 这种树形数据结构十分容易形象地绘成图形 如图所示，线段树有以下性质: 线段树本质是棵二叉树. 线段树每个节点是代表一个区间[l,r],而每个节点的两个子树分别[l,mid],[mid+1,r]。 叶子节点l等于r且长度为1 线段树深度不超过logn 综上所述，我们可以按二叉树的建树方法...
学习笔记——线段树
No_wonder の 小站
08-11 298
线段树 本文主要来自百度百科和这篇blog 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 长这样 对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。 基本结构与建造 线段树是建立在线段的基础上，每个结点都代表了一条线段[a,b]。长度为1的线段称为元线段。非元线段都有两个子结点，左结点代表的线
树形数据结构学习笔记1——线段树与树状数组
m0_52048145的博客
01-24 309
在谈树形数据结构之前，先考虑一类问题： 现在要维护一个数列，我需要进行单点或者区间的修改（区间[l,r][l,r][l,r]上都要执行同一个操作），要进行区间的求值，例如求单点或区间和、求单点或区间最大值最小值等等。 这里引出了一个问题，那就是操作的范围，通常有以下两种：单点与区间的修改与求值。而这个直接关系到使用哪一种数据结构的问题，这一问题将在附记3中详解，这里先粗略给一个结论：只存在单点的修改或求值的，可以使用树状数组；既存在区间修改又存在区间求值的，使用线段树 此外，还有另外一个问题关于数据结构的存
c++数据结构进阶线段树习题
07-05
针对线段树的四道c++习题
权值线段树及扫描线学习笔记
12-25
权值线段树及扫描线学习笔记
数据结构课程设计-线段树
06-08
数据结构课程的课程设计
统计的力量——线段树全接触_张昆玮.pptx
09-17
统计的力量-zkw线段树 zkw的讲课ppt，线段树经典之作，内含一种采用堆式存储的zkw线段树及其使用方法
数据结构 | 详解栈实现队列&队列实现栈
mooridy的博客
05-17 327
step2：此时非空队列中剩下的唯一一个数就是“栈顶”元素，使用QueueFront进行·取值后，直接进行QueuePop删除。step0.先利用假设法假定非空队列notempty和空队列empty，再利用MyStackEmpty函数对进行修正。step1:将notempty队列中的前size-1个元素依次push到empty队列中，再进行删除，实现移动操作。
USB3.0接口——（2）数据结构
dkmknjk的博客
05-14 1064
在 USB 3.0 及更高版本的 xHCI 协议中，"Rings"、"Transfer Request Block (TRB)" 和 "Transfer Descriptor (TD)" 是用于管理 USB 数据传输和事件的重要概念。
「探索数据结构：了解顺序表」
2301_80321602的博客
05-17 528
顺序表是一种线性表的存储结构，它是由一组物理地址连续的存储单元（通常是数组）依次存储线性表中的元素。顺序表中的元素在内存中是连续存储的，通过元素在数组中的下标来访问和操作元素。顺序表的优点是访问元素的时间复杂度为O(1)，即可以通过下标直接访问元素，操作效率高；缺点是插入和删除元素时需要移动其他元素，时间复杂度为O(n)，效率较低。首先，我们需要定义动态顺序表的数据类型SLDataType和结构体SeqList。动态顺序表使用数组arr存储数据，size表示当前有效数据个数，capacity。
“ 树 ” 的概念
2401_82669797的博客
05-14 688
通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。：若一个结点含有子结点，则这个结点称为其子结点的父结点；：以某结点为根的子树中任一结点都称为该结点的子孙。：一个结点含有的子树的根结点称为该结点的子结点；具有相同父结点的结点互称为兄弟结点；：一个结点含有的子树的个数称为该结点的度；：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
数据结构选择题
m0_67187271的博客
05-17 367
由于是对称矩阵，我们可以将其压缩存储到一维数组中，只需存储上三角部分的元素加上对角线的元素，即 ( 45 + 10 = 55 ) 个元素。现在，我们再次添加一个元素 'f'，其下标为 1（因为队列是循环的），此时尾指针 r 回到了 1 的位置。选项A描述的是有一个以上根结点的数据结构，这在标准的数据结构分类中并不存在，因为根结点通常指的是树或图结构的起始点，而一个结构中只能有一个起点。因此，正确答案是B，只有一个根结点的数据结构不一定是线性结构，这可能指的是树或图结构，它们是非线性结构。
数据结构 之 Map & Set
最新发布
AUGENSTERN_dc的博客
05-18 943
Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。以前常见的 搜索方式有： 直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢 二分查找，时间复杂度为,但搜索前必须要求序列是有序的 上述排序比较适合静态类型的查找，即一般不会对区间进行插入和删除操作了，而现实中的查找比如： 根据姓名查询考试成绩 通讯录，即根据姓名查询联系方式 不重复集合，即需要先搜索关键字是否已经在集合中 可能在查找时进行一些插入和删除的操作，即动态查找，那上述两种方式就不太适合了，本
数据结构——01-抽奖数人-链表-实验题目与解答
——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
05-14 904
在抽奖过程中，我通过循环和条件判断来模拟报数过程，并在每次报数到m时，输出中奖者的编号，并从数组中移除该编号。n个人围成一圈，由第一个人开始，依次报数，数到第m人，便抽出来作为中奖人，然后从他的下一个人数起，数到第m人，再抽出来作为中奖人，如此循环，直到抽出k个为止。在本次实验中，我深入探索了数据结构的魅力，通过实现一个抽奖游戏，我不仅巩固了对顺序存储结构和链式存储结构的理解，还提升了我的编程实践能力。当k>0时，从index开始循环数组，每数到第m个人，就将其编号输出，并从数组中移除该编号。
【数据结构】树（Tree）
SWsunlight的博客
05-16 653
树、二叉树
数据结构-队列(带图详解)
2302_78381559的博客
05-17 1074
链表是一种基本的数据结构，它用于存储一系列元素（节点），每个节点不仅包含数据元素，还包含一个指向下一个节点的指针。在链表中，数据并非连续地存储在内存中，而是通过每个节点的指针链接起来形成一个逻辑上的线性序列通过前面我们学习的顺序表我们现在延伸一个链表我们会发现顺序表的一些缺点。：顾客在超市收银台前排队等待付款，先到的顾客先完成结账离开，后来的顾客依次跟进。：在餐厅，特别是快餐店，顾客排队等待点餐和取餐，先排队的顾客先完成点餐流程。：在办公室，多个人提交打印任务时，打印机会按照任务提交的顺序依次执行打印。
Python 线段树
10-06
Python中的线段树是一种用于解决区间查询问题的数据结构。线段树可以被看作是一棵二叉树，其中每个节点代表了一个区间。每个内部节点都有两个子节点，左子节点代表区间的左半部分，右子节点代表区间的右半部分。叶...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值