简单的例题
给出区间 在这个区间上我们分别加上x
很简单的题目
给出代码 这是最容易的想法 但是肯定是过不去的
#include <iostream>
using namespace std;
#define _rep(i,a,b) for(int i=(a);i<=(b);++i)
#define _for(i,a,b) for(int i=(a);i<(b);++i)
const int MAXN = 1e5 +6;
int t;
int m,n;
int a[MAXN];
int readint(){int x;scanf("%d",&x);return x;}
int main(){
t=readint();
while(t--){
n=readint();
_rep(i,1,n) a[i]=readint();
m=readint();
while(m--){
int l=readint();
int r=readint();
int x=readint();
_rep(i,l,r) a[i]+=x;
}
_rep(i,1,n) if(i!=n) cout<<a[i]<<" ";else cout<<a[i];
cout<<endl;
}
return 0;
}
代码估计是tle了
算法复杂度很高这题肯定不行
接下来要用差分的思想
差分
上面的代码可以看出复杂度应该是O(N2)
对于稍微大点的数据就tle
那肯定不行啊
所以我们需要另一个数组记录区间要加x的信息
如何优化 本质上就是减少对循环的使用
那么在
while(m--){
int l=readint();
int r=readint();
int x=readint();
_rep(i,l,r) a[i]+=x;
}
在这段中 我们发现while里面还有一个for
这样复杂度一下子就提高了
我们定义aux数组来记录m个区间操作
那么核心的代码就是如此了
while(m--){
int l=readint();
int r=readint();
int x=readint();
aux[l]+=x;
aux[r+1]-=x;
}
aux数组l+=x,r+1-=x
为什么呢
就要用到下面这个操作解释
_rep(i,2,n) aux[i]+=aux[i-1];
数组加自己前面那个数
比如aux3+=3
aux6-=3
一开始aux数组都是0
那么aux4=aux4+aux3
所以aux4=3
一直到n结束
那么如果超过要修改的区间r了呢
所以在aux6-=3
aux6=-3 所以他处理后aux6=aux6+aux5 就变成了0
遍历到n后面都是0
就保证了l - r区间内的信息都保存在aux中了
根据上面的操作 我们可以简单的看出不管aux被操作多少次
也就是说aux被操作m次 他还是保存了区间内所有的信息
_rep(i,1,n) {a[i]+=aux[i];if(i!=n)cout<<a[i]<<" ";else cout<<a[i]<<endl;}
在输出前 a[i]+=aux[i];
通过aux中的信息修改a
我们可以发现
循环变成了一个 不存在循环中还有循环的问题
复杂度来到了O(N)
那么这题就是过了
完整的代码
#include <iostream>
using namespace std;
#define _rep(i,a,b) for(int i=(a);i<=(b);++i)
#define _for(i,a,b) for(int i=(a);i<(b);++i)
inline int readint(){int x;scanf("%d",&x);return x;}
const int MAXN=1e5+5;
int t;
int m,n;
int a[MAXN];
int aux[MAXN];
int main(){
t=readint();
while(t--){
n=readint();
_rep(i,1,n) a[i]=readint();
m=readint();
while(m--){
int l=readint();
int r=readint();
int x=readint();
aux[l]+=x;
aux[r+1]-=x;
}
_rep(i,2,n) aux[i]+=aux[i-1];
_rep(i,1,n) {a[i]+=aux[i];if(i!=n)cout<<a[i]<<" ";else cout<<a[i]<<endl;}
}
return 0;
}
那会不会有比O(N)更加快的呢
复杂度表上好像有一个O(logN)吧
线段树
这个我自己也不是能讲的很清楚
简单的说 就是这些信息都用一个二叉树 而且是完全二叉树来维护
先说
建树
void build(int l,int r,int rt){
add[rt]=0;
if(l==r){
scanf("%lld",&sum[rt]);
return;
}
int mid=(l+r)>>1;
build(lson);
build(rson);//建树到最底层 退出递归到倒数第二层 向下跟新一层 在退出一层 再向下更新一层 完成向上更新区间和
push_up(rt);
}
这里我们用了个宏定义简化了代码
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
左移相当于乘以2
下面那个相当于乘以2 再+1
就不多说了
代码明显看出 我们输入的数据再树的底层
他们的父节点都用来记录区间和了
两个更新操作
void push_up(int rt){//向上更新
sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}
void push_down(int rt,int m){
if(add[rt]){
add[rt<<1]+=add[rt];
add[rt<<1|1]+=add[rt];
sum[rt<<1]+=(m-(m>>1))*add[rt];
sum[rt<<1|1]+=(m>>1)*add[rt];
//向下更新
add[rt]=0;
}
}
add是lazy tag
用来记录修改的信息的 我是这么理解的
因为再访问区间和的时候 我们会发现 修改一个值后
需要不断的向下更新那么这tm不是废了吗
所以有了这么个玩意 在需要使用的时候 就访问 并更新
push down操作显而易见是向下更新的操作
push up是向上更新的操作
两个重要操作
显然我不知道叫啥好了
void update(int a,int b,long long c,int l,int r,int rt){
if(a<=l && b>=r){
sum[rt]+=(r-l+1)*c;//更新区间和
add[rt]+=c;//添加lazy标记
return;
}
push_down(rt,r-l+1);//向下更新被修改的区间
int mid=(l+r)>>1;
if(a<=mid) update(a,b,c,lson);
if(b>mid) update(a,b,c,rson);
push_up(rt);
}
long long query(int a,int b,int l,int r,int rt){
if(a<=l && b>=r) return sum[rt];//被查找区间 已经包含
//没有被包含 需要访问下面的 所以向下更新
push_down(rt,r-l+1);
int mid=(l+r)>>1;
long long ans=0;
if(a<=mid) ans+=query(a,b,lson);
if(b>mid) ans+=query(a,b,rson);
return ans;
}
第一个函数是修改区间操作的
参数a b c 是要修改的区间 和 修改的数值 这个修改是加上这个值
update中发现被查区间包含了所在节点的区间 将区间更新并且添加lazy tag 然后return 他的任务已经结束了
那么有些问题就有了 返回的区间并不全啊 只是包含了节点区间 那其他的数值呢
当然 这个是递归函数 其他的数会由另外的栈帧返回提供
如果没有包含
就向下更新 保证add中为0
如果a<=mid了我们查一次左边
如果b>mid了我们查一次右边
因为我们在定义的时候将mid划分给了左子树
所以a有个等号 这是我的理解
最后我们这个栈帧的任务也结束了。
第二个函数相当的相似
我们发现包含该节点区间我们就返回节点的区间和
否则 我们查左边 查右边 返回ans
完成任务 和上一个函数的思想是相同的
线段树的操作这里就没了
接下来是神仙的main 我们要解决差分问题了
但是我们会有一个惊奇的发现
int main(){
t=readint();
while(t--){
n=readint();
build(1,n,1);
m=readint();
while(m--){
int l=readint();
int r=readint();
int x=readint();
update(l,r,x,1,n,1);
}
_rep(i,1,n) if(i!=n) cout<<query(i,i,1,n,1)<<" ";else cout<<query(i,i,1,n,1)<<endl;
}
return 0;
}
在返回这个值的时候我们简直惊呆了
query(i,i,1,n,1)
这个操作到底是什么玩意
这样子访问 每个返回不都是要到最底下的子节点了吗
那么复杂度不还是O(N)
对线段树的优点避开了 惊
那我们知道最后的数据都在最底下 因为这是完全二叉树
所以我们可以添加一个变量
1<<(int(log(n)/log(2))+1)
这个能算出最底下的那个节点在数组的下标
然而这样的操作好像只是美化了代码的逻辑
所以没起到啥优化 emmm应该吧
下面是所有的代码
#include <iostream>
using namespace std;
#define _rep(i,a,b) for(int i=(a);i<=(b);++i)
#define _for(i,a,b) for(int i=(a);i<(b);++i)
inline int readint(){int x;scanf("%d",&x);return x;}
const int MAXN=1e5 +10;
long long sum[4*MAXN];
long long add[4*MAXN];//add是lazy标签
int t,n,m;
void push_up(int rt){//向上更新
sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}
void push_down(int rt,int m){
if(add[rt]){
add[rt<<1]+=add[rt];
add[rt<<1|1]+=add[rt];
sum[rt<<1]+=(m-(m>>1))*add[rt];
sum[rt<<1|1]+=(m>>1)*add[rt];
//向下更新
add[rt]=0;
}
}
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
void build(int l,int r,int rt){
add[rt]=0;
if(l==r){
scanf("%lld",&sum[rt]);
return;
}
int mid=(l+r)>>1;
build(lson);
build(rson);//建树到最底层 退出递归到倒数第二层 向下跟新一层 在退出一层 再向下更新一层 完成向上更新区间和
push_up(rt);
}
void update(int a,int b,long long c,int l,int r,int rt){
if(a<=l && b>=r){
sum[rt]+=(r-l+1)*c;//更新区间和
add[rt]+=c;//添加lazy标记
return;
}
push_down(rt,r-l+1);//向下更新被修改的区间
int mid=(l+r)>>1;
if(a<=mid) update(a,b,c,lson);
if(b>mid) update(a,b,c,rson);
push_up(rt);
}
long long query(int a,int b,int l,int r,int rt){
if(a<=l && b>=r) return sum[rt];//被查找区间 已经包含
//没有被包含 需要访问下面的 所以向下更新
push_down(rt,r-l+1);
int mid=(l+r)>>1;
long long ans=0;
if(a<=mid) ans+=query(a,b,lson);
if(b>mid) ans+=query(a,b,rson);
return ans;
}
int main(){
t=readint();
while(t--){
n=readint();
build(1,n,1);
m=readint();
while(m--){
int l=readint();
int r=readint();
int x=readint();
update(l,r,x,1,n,1);
}
_rep(i,1,n) if(i!=n) cout<<query(i,i,1,n,1)<<" ";else cout<<query(i,i,1,n,1)<<endl;
}
return 0;
}
线段树并不是只能解决+问题 可以修改的 哎 先这样吧
很多理解都是我自己的 可能不正确
😴晚安