蒟蒻blogDay1-差分数组-线段树

最新推荐文章于 2024-07-19 23:11:36 发布

Dstan90

最新推荐文章于 2024-07-19 23:11:36 发布

阅读量92

点赞数

分类专栏：算法文章标签： c++ 算法

本文链接：https://blog.csdn.net/qian_su/article/details/120508207

版权

算法专栏收录该内容

4 篇文章 0 订阅

订阅专栏

简单的例题
请添加图片描述

给出区间在这个区间上我们分别加上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;
}