线段树训练

最新推荐文章于 2024-08-29 22:25:44 发布
最新推荐文章于 2024-08-29 22:25:44 发布
阅读量916 收藏 10
点赞数 8
文章标签： 算法 c++ c语言 数据结构 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74310050/article/details/140699427
版权

线段树

什么是线段树？

线段树是一种二叉搜索树，而二叉搜索树，首先满足二叉树，即每个结点最多有两颗子树，并且是一颗搜索树，我们要知道，线段树的每个结点都存储了一个区间，也可以理解成一个线段，而搜索，就是在这些线段上进行搜索操作得到你想要的答案。（处理区间问题）

只能维护带有结合律的信息：（1）总数字之和=左区间数字之和+右区间数字之和（2）总gcd=gcd（左区间gcd，右区间gcd）（3）总最大值=max(左区间最大值，右区间最大值)。

单点修改，区间查询

洛谷p1531黄

题意；有n个同学m个操作，第二行n个正数，第i个数代表第i个同学的成绩。操作有两种：询问区间内最大的数；小于b的成绩更新为b。

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5e5+10;
ll a[N];
struct A{
    int l,r;//区间
    ll lazy;//懒标记
    ll sum;//维护
}tr[N<<2];
void pushup(int u){//得到两个子区间的区间和
    tr[u].sum=max(tr[u<<1].sum,tr[u<<1|1].sum);
}
void build(int u,int l,int r){//建树
    tr[u].l=l;
    tr[u].r=r;
    if(l==r){
        tr[u].sum=a[l];
        return;
    }
    int mid=l+r>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    pushup(u);//从子节点向父节点的信息整合
}
void update(int u,int pos,int k){//区间更新
    if(tr[u].l==tr[u].r){
        if(tr[u].sum<k){
            tr[u].sum=k;    
        }
        return;
    }
    int mid=(tr[u].l+tr[u].r)>>1;
    if(pos<=mid)update(u<<1,pos,k);
    else update(u<<1|1,pos,k);
    pushup(u);
}
ll query(int u,int l,int r){//区间查询
    if(tr[u].l>=l&&tr[u].r<=r)return tr[u].sum;
    int mid=(tr[u].l+tr[u].r)>>1;
    ll ma=0;
    if(l<=mid)ma=max(ma,query(u<<1,l,r));
    if(r>mid)ma=max(ma,query(u<<1|1,l,r));
    return ma;
}
int main(){
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++)cin>>a[i];
    build(1,1,n);
    for(int i=1;i<=m;i++){
        char t;cin>>t;
        if(t=='U'){
            ll x,y;cin>>x>>y;
            update(1,x,y);
        }
        else{
            ll x,y;cin>>x>>y;
            cout<<query(1,x,y)<<endl;
        }
    }
    return 0;
}
洛谷p3374黄

1 x k:将第x个数加上k

2 x y：输出区间x，y内每个数的和。

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5e5+10;
ll a[N];
struct A{
    int l,r;//区间
    ll lazy;//懒标记
    ll sum;//维护
}tr[N<<2];
void pushup(int u){//得到两个子区间的区间和
    tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;
}
void build(int u,int l,int r){//建树
    tr[u].l=l;
    tr[u].r=r;
    if(l==r){
        tr[u].sum=a[l];
        return;
    }
    int mid=l+r>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    pushup(u);//从子节点向父节点的信息整合
}
void update(int u,int pos,int k){//区间更新
    if(tr[u].l==tr[u].r){
        tr[u].sum+=k;
        return;
    }
    int mid=(tr[u].l+tr[u].r)>>1;
    if(pos<=mid)update(u<<1,pos,k);
    else update(u<<1|1,pos,k);
    pushup(u);
}
ll query(int u,int l,int r){//区间查询
    if(tr[u].l>=l&&tr[u].r<=r)return tr[u].sum;
    int mid=(tr[u].l+tr[u].r)>>1;
    ll ma=0;
    if(l<=mid)ma+=query(u<<1,l,r);
    if(r>mid)ma+=query(u<<1|1,l,r);
    return ma;
}
int main(){
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++)cin>>a[i];
    build(1,1,n);
    for(int i=1;i<=m;i++){
        int t;cin>>t;
        if(t==1){
            ll x,y;cin>>x>>y;
            update(1,x,y);
        }
        else{
            ll x,y;cin>>x>>y;
            cout<<query(1,x,y)<<endl;
        }
    }
    return 0;
}

区间修改，单点查询

洛谷p3368黄

1 x y k :将区间x，y内每个数加上k

2 x输出第x个数的值

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5e5+10;
ll a[N];
struct A{
    int l,r;//区间
    ll lazy;//懒标记
    ll sum;//维护
}tr[N<<2];
void pushup(int u){//得到两个子区间的区间和
    tr[u].sum=min(tr[u<<1].sum,tr[u<<1|1].sum);
}
void build(int u,int l,int r){//建树
    tr[u].l=l;
    tr[u].r=r;
    if(l==r){
        tr[u].sum=a[l];
        return;
    }
    int mid=l+r>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    pushup(u);//从子节点向父节点的信息整合
}
void pushdown(int u){//懒标记的传递
    if(tr[u].lazy){
        tr[u<<1].lazy+=tr[u].lazy;
        tr[u<<1].sum+=(tr[u<<1].r-tr[u<<1].l+1)*tr[u].lazy;
        tr[u<<1|1].lazy+=tr[u].lazy;
        tr[u<<1|1].sum+=(tr[u<<1|1].r-tr[u<<1|1].l+1)*tr[u].lazy;
        tr[u].lazy=0;
    }
}
void update(int u,int l,int r,int k){//区间更新
    if(l<=tr[u].l&&r>=tr[u].r){
        tr[u].sum+=(tr[u].r-tr[u].l+1)*k;
        tr[u].lazy+=k;
        return;
    }
    pushdown(u);
    int mid=tr[u].l+tr[u].r>>1;
    if(l<=mid)update(u<<1,l,r,k);
    if(r>mid)update(u<<1|1,l,r,k);
    pushup(u);
}
ll query(int u,int pos,int l,int r){//单点查询
    if(l==r)return tr[u].sum;
    pushdown(u);
    int mid=tr[u].l+tr[u].r>>1;
    if(pos<=mid)return query(u<<1,pos,l,mid);
    else if(pos>mid)return query(u<<1|1,pos,mid+1,r);
}
int main(){
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++)cin>>a[i];
    build(1,1,n);
    for(int i=1;i<=m;i++){
        int t;cin>>t;
        if(t==1){
            int l,r;ll k;cin>>l>>r>>k;
            update(1,l,r,k);
        }
        else{
            int x;cin>>x;
            cout<<query(1,x,1,n)<<endl;
        }
    }
}

区间加法

洛谷p3372绿

1 x y k:将区间x，y内每个数加上k

2 x y：输出区间x，y内每个数的和

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10;
int a[N];
struct A{
    int l,r;//区间
    ll lazy;//懒标记
    ll sum;//维护
}tr[N<<2];
void pushup(int u){//得到两个子区间的区间和
    tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;
}
void build(int u,int l,int r){//建树
    tr[u].l=l;
    tr[u].r=r;
    if(l==r){
        tr[u].sum=a[l];
        return;
    }
    int mid=l+r>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    pushup(u);//从子节点向父节点的信息整合
}
void pushdown(int u){//懒标记的传递
    if(tr[u].lazy){
        tr[u<<1].lazy+=tr[u].lazy;
        tr[u<<1].sum+=(tr[u<<1].r-tr[u<<1].l+1)*tr[u].lazy;
        tr[u<<1|1].lazy+=tr[u].lazy;
        tr[u<<1|1].sum+=(tr[u<<1|1].r-tr[u<<1|1].l+1)*tr[u].lazy;
        tr[u].lazy=0;
    }
}
void update(int u,int l,int r,int k){//区间更新
    if(l<=tr[u].l&&r>=tr[u].r){
        tr[u].lazy+=k;
        tr[u].sum+=(tr[u].r-tr[u].l+1)*k;
        return;
    }
    pushdown(u);
    int mid=tr[u].l+tr[u].r>>1;
    if(l<=mid)update(u<<1,l,r,k);
    if(r>mid)update(u<<1|1,l,r,k);
    pushup(u);
}
ll query(int u,int l,int r){//区间查询
    if(l<=tr[u].l&&r>=tr[u].r)return tr[u].sum;
    pushdown(u);
    int mid=tr[u].l+tr[u].r>>1;
    ll res=0;
    if(l<=mid)res+=query(u<<1,l,r);
    if(r>mid)res+=query(u<<1|1,l,r);
    return res;
}
int main(){
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++)cin>>a[i];
    build(1,1,n);
    for(int i=1;i<=m;i++){
        int t;cin>>t;
        if(t==1){
            int l,r;ll k;cin>>l>>r>>k;
            update(1,l,r,k);
        }
        else{
            int l,r;cin>>l>>r;
            cout<<query(1,l,r)<<endl;
        }
    }
}

区间乘法

洛谷p3373绿

1 x y k将区间内每个数乘上k

2 x y k将区间内每个数加上k

3 x y输出区间x，y内每个数的和并取模

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10;
int a[N],p;
struct A{
    int l,r;//区间
    ll add;//懒标记
    ll mul;
    ll sum;//维护
}tr[N<<2];
void pushup(int u){//得到两个子区间的区间和
    tr[u].sum=(tr[u<<1].sum+tr[u<<1|1].sum)%p;
}
void build(int u,int l,int r){//建树
    tr[u].l=l;
    tr[u].r=r;
    tr[u].add=0;
    tr[u].mul=1;
    if(l==r){
        tr[u].sum=a[l];
        return;
    }
    int mid=l+r>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    pushup(u);//从子节点向父节点的信息整合
}
void pushdown(int u){//懒标记的传递
    if(tr[u].mul!=1){
        tr[u<<1].mul=(tr[u<<1].mul*tr[u].mul)%p;
        tr[u<<1].add=(tr[u<<1].add*tr[u].mul)%p;
        tr[u<<1].sum=(tr[u<<1].sum*tr[u].mul)%p;
        tr[u<<1|1].mul=(tr[u<<1|1].mul*tr[u].mul)%p;
        tr[u<<1|1].add=(tr[u<<1|1].add*tr[u].mul)%p;
        tr[u<<1|1].sum=(tr[u<<1|1].sum*tr[u].mul)%p;
        tr[u].mul=1;
    }
    if(tr[u].add){
        tr[u<<1].add=(tr[u<<1].add+tr[u].add)%p;
        tr[u<<1].sum=(tr[u<<1].sum+tr[u].add*(tr[u<<1].r-tr[u<<1].l+1)%p)%p;
        tr[u<<1|1].add=(tr[u<<1|1].add+tr[u].add)%p;
        tr[u<<1|1].sum=(tr[u<<1|1].sum+tr[u].add*(tr[u<<1|1].r-tr[u<<1|1].l+1)%p)%p;
        tr[u].add=0;
    }
}
void modify(int u,int l,int r,ll v1,ll v2){
    if(l<=tr[u].l&&r>=tr[u].r){
        tr[u].mul=(tr[u].mul*v1)%p;
        tr[u].add=(tr[u].add*v1)%p;
        tr[u].sum=(tr[u].sum*v1)%p;
        tr[u].add=(tr[u].add+v2)%p;
        tr[u].sum=(tr[u].sum+v2*(tr[u].r-tr[u].l+1))%p;
        return;
    }
    pushdown(u);
    int mid=(tr[u].l+tr[u].r)>>1;
    if(l<=mid)modify(u<<1,l,r,v1,v2);
    if(r>mid)modify(u<<1|1,l,r,v1,v2);
    pushup(u);
}
ll query(int u,int l,int r){//区间查询
    if(l<=tr[u].l&&r>=tr[u].r){
        return tr[u].sum;
    }
    pushdown(u);
    int mid=(tr[u].l+tr[u].r)>>1;
    ll res=0;
    if(l<=mid)res=query(u<<1,l,r);
    if(r>mid)res=(res+query(u<<1|1,l,r))%p;
    return res;
}
int main(){
    int n,m;cin>>n>>m>>p;
    for(int i=1;i<=n;i++)cin>>a[i];
    build(1,1,n);
    for(int i=1;i<=m;i++){
        int t;cin>>t;
        if(t==1){
            int l,r;ll k;cin>>l>>r>>k;
            modify(1,l,r,k,0);
        }
        else if(t==2){
            int l,r;ll k;cin>>l>>r>>k;
            modify(1,l,r,1,k);
        }
        else{
            int l,r;cin>>l>>r;
            cout<<query(1,l,r)<<endl;
        }
    }
    return 0;
}

区间根号

洛谷p4145蓝

0 l r：区间l，r每个数开平方

1 l r：输出区间l，r内每个数的和

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e6+10;
ll a[N];
​
struct A{
    ll l,r;//区间
    ll add;//懒标记
    ll maxn;
    ll sum;//维护
}tr[N<<2];
void pushup(ll 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(ll u,ll l,ll r){//建树
    tr[u].l=l;
    tr[u].r=r;
    if(l==r){
        tr[u].sum=tr[u].maxn=a[l];
        return;
    }
    ll mid=l+r>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    pushup(u);//从子节点向父节点的信息整合
}
void modify(ll u,ll l,ll r){
    if(tr[u].l==tr[u].r){
        if(tr[u].maxn>1){
            tr[u].sum=sqrt(tr[u].sum);
            tr[u].maxn=sqrt(tr[u].maxn);
        }
        return;
    }
    ll mid=(tr[u].l+tr[u].r)>>1;
    if(l<=mid&&tr[u<<1].maxn>1)modify(u<<1,l,r);
    if(r>mid&&tr[u<<1|1].maxn>1)modify(u<<1|1,l,r);
    pushup(u);
}
ll query(ll u,ll l,ll r){//区间查询
    if(l<=tr[u].l&&r>=tr[u].r){
        return tr[u].sum;
    }
    ll mid=(tr[u].l+tr[u].r)>>1;
    ll res=0;
    if(l<=mid)res+=query(u<<1,l,r);
    if(r>mid)res+=query(u<<1|1,l,r);
    return res;
}
int main(){
    int n;scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%lld",&a[i]);
    int m;scanf("%d",&m);
    build(1,1,n);
    for(int i=1;i<=m;i++){
        int t,l,r;
        scanf("%d%d%d",&t,&l,&r);
        if(t==0){
            if(l>r)swap(l,r); 
            modify(1,l,r);
        }
        else{
            if(l>r)swap(l,r);
            cout<<query(1,l,r)<<endl;
        }
    }
    return 0;
}

例题

例1 cf438d（蓝)

题意：有长度为n的数组a，执行m个操作：

1 l r：输出区间内每个数的和

2 l r x：区间内每个数取模，模为x

3 k x： ak修改为x

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10;
int a[N];
struct A{
    int l,r;//区间
    ll maxn;//懒标记
    ll sum;//维护
}tr[N<<2];
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){//建树
    tr[u].l=l;
    tr[u].r=r;
    if(l==r){
        tr[u].sum=a[l];
        tr[u].maxn=a[l];
        return;
    }
    int mid=l+r>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    pushup(u);//从子节点向父节点的信息整合
}
void modify1(int u,int l,int r,int x){
    if(l<=tr[u].l&&r>=tr[u].r){
        if(tr[u].maxn<x)return;
    }
    if(tr[u].l==tr[u].r){
        tr[u].maxn=tr[u].maxn%x;
        tr[u].sum=tr[u].sum%x;
        return;
    }
    int mid=tr[u].l+tr[u].r>>1;
    if(l<=mid)modify1(u<<1,l,r,x);
    if(r>mid)modify1(u<<1|1,l,r,x);
    pushup(u);
}
void modify2(int u,int k,int v){
    if(tr[u].l==tr[u].r){
        if(tr[u].l==k){
            tr[u].maxn=v;
            tr[u].sum=v;
        }
        return;
    }
    int mid=tr[u].l+tr[u].r>>1;
    if(k<=mid)modify2(u<<1,k,v);
    else modify2(u<<1|1,k,v);
    pushup(u);
}
ll query(int u,int l,int r){//区间查询
    if(l<=tr[u].l&&r>=tr[u].r)return tr[u].sum;
    int mid=tr[u].l+tr[u].r>>1;
    ll res=0;
    if(l<=mid)res+=query(u<<1,l,r);
    if(r>mid)res+=query(u<<1|1,l,r);
    return res;
}
int main(){
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++)cin>>a[i];
    build(1,1,n);
    for(int i=1;i<=m;i++){
        int t;cin>>t;
        if(t==1){
            int l,r;cin>>l>>r;
            cout<<query(1,l,r)<<endl;
        }
        else if(t==2){
            int l,r;cin>>l>>r;
            ll x;cin>>x;
            modify1(1,l,r,x);
        }
        else{
            int k;ll x;cin>>k>>x;
            modify2(1,k,x);
        }
    }
}

例2 p5142（蓝）

1 x y：将bx赋值为y

2 x y：输出bx到by的方差

分析：

∑（a[i]+x)²

=a1²+a2²+。。an²+2x（a1+a2+。。an）+nx²

=sum2[n]+2xsum1[n]+nx²=∑xi²/n-平均数²

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10;
int a[N],p;
const ll mod=1e9+7;
int qpow(int b, int p = mod - 2, int m = mod) {
    // 快速幂用于费马小定理求逆元 
    b %= m;
    int s = 1 % m;
    for(; p; p >>= 1, b = (ll)b * b % m)
        if(p & 1) s = (ll)s * b % m;
    return s;
}
struct A{
    ll l,r;//区间
    ll sum;//维护
}tr[N<<2];
struct B{
    ll l,r;
    ll sum;//维护
}tr2[N<<2];
void pushup(int u){//得到两个子区间的区间和
    tr[u].sum=(tr[u<<1].sum+tr[u<<1|1].sum)%mod;
    tr2[u].sum=(tr2[u<<1].sum+tr2[u<<1|1].sum)%mod;
}
void build(ll u,ll l,ll r){//建树
    tr[u].l=l;
    tr[u].r=r;
    tr2[u].l=l;
    tr2[u].r=r;
    if(l==r){
        tr[u].sum=a[l]%mod;
        tr2[u].sum=((ll)a[l]*a[l])%mod;
        return;
    }
    ll mid=l+r>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    pushup(u);//从子节点向父节点的信息整合
}
ll query1(int u,int l,int r) {
        if(l==tr[u].l&&r==tr[u].r)return tr[u].sum%mod;
        int m=(tr[u].l+tr[u].r)>>1;
        if(r<=m)return query1(u<<1,l,r) % mod;
        if(l>m)return query1(u<<1|1,l,r) % mod;
        return(query1(u<<1,l,m)+query1(u<<1|1,m+1,r))%mod;
}
ll query2(int u,int l,int r) {
        if(l==tr2[u].l&&r==tr2[u].r)return tr2[u].sum%mod;
        int m=(tr2[u].l+tr2[u].r)>>1;
        if(r<=m)return query2(u<<1,l,r) % mod;
        if(l>m)return query2(u<<1|1,l,r) % mod;
        return(query2(u<<1,l,m)+query2(u<<1|1,m+1,r))%mod;
}
void update1(ll u,ll pos,ll k){//区间更新
    if(tr[u].l==tr[u].r){
        tr[u].sum=(ll)k%mod;
        tr2[u].sum=((ll)k*k%mod)%mod;
        return;
    }
    ll mid=(tr[u].l+tr[u].r)>>1;
    if(pos<=mid)update1(u<<1,pos,k);
    else update1(u<<1|1,pos,k);
    pushup(u);
}
int main(){
    ll n,m;cin>>n>>m;
    for(int i=1;i<=n;i++)cin>>a[i];
    build(1,1,n);
    for(int i=1;i<=m;i++){
        ll t;cin>>t;ll x,y;cin>>x>>y;
        if(t==1){
            update1(1,x,y%mod);
        }
        else{
            ll s1=query1(1,x,y)%mod;//区间和
            ll s2=query2(1,x,y)%mod;//区间平方和
            ll len=qpow(y-x+1);//区间长度的倒数 
            ll ave=(ll)s1*len%mod;//平均数 
            ll ans=(ll)s2*len%mod-((ll)ave*ave%mod)%mod;
            ans=(ans%mod+mod)%mod;//防止出现负数
            cout<<ans<<endl; 
             
            
        }
    }
    return 0;
}
c沫栀
关注
  • 8
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【hdu 1754】I Hate It 【线段树 训练1】
skysys的研究小屋
07-28 447
Description 很多学校流行一种比较的习惯。老师们很喜欢询问，从某某到某某当中，分数最高的是多少。 这让很多学生很反感。不管你喜不喜欢，现在需要你做的是，就是按照老师的要求，写一个程序，模拟老师的询问。当然，老师有时候需要更新某位同学的成绩。Input 本题目包含多组测试，请处理到文件结束。 在每个测试的第一行，有两个正整数 N 和 M ( 0#include<cstdio> #in
【HDU 1394】Minimum Inversion Number 【线段树 训练2】
skysys的研究小屋
07-28 467
Problem Description The inversion number of a given number sequence a1, a2, …, an is the number of pairs (ai, aj) that satisfy i < j and ai > aj.For a given sequence of numbers a1, a2, …, an, if we mo
线段树
Spground
04-14 628
线段树 线段树（英语：Segment tree）是一种二叉树形数据结构，1977年由Jon Louis Bentley发明[1]，用以储存区间或线段，并且允许快速查询结构内包含某一点的所有区间。 线段树常常用对区间数据的更新和查询，主要的作用就是体现在对区间的处理。 最常见就是这样一个问题： 现在有一个长度为nnn的数组a[i]a[i]a_{[i]}，给定一个区间iii~jjj，返...
线段树练习
KingTom
12-14 178
线段树练习POJ2828 POJ2828 由于前面来的人会有被插队的可能，因此从前往后处理排队的人会使得已经在数组中的人位置不断变化，增加计算量；可考虑从后往前处理：此时这人只要一入数组，就不可能会被插队，也就是说位置不会再变； 使用权值线段树解决：定义que为最后的队列，blank为该节点剩余空位； 考虑这么一种情况：最后一个人插到位置1，此时剩下位置2、3、4，倒数第二人想要插入到位置2，但其实这个位置是相对于早于他之前来的人而非相对于这最后一人，而节点2维护的位置区间只剩下一个位置留给前面的
线段树应用
Ma_tx
08-11 3544
下面给出线段树的几个应用： （1）有一列数，初始值全部为0。每次可以进行以下三种操作中的一种： a. 给指定区间的每个数加上一个特定值； b.将指定区间的所有数置成一个统一的值； c.询问一个区间上的最小值、最大值、所有数的和。 给出一系列a.b.操作后，输出c的结果。 [问题分析] 这个是典型的线段树的应用。在每个节点上维护一下几个变量：delta（区间增加值），same（区间被置
线段树+模拟——借教室
虞念巧
09-23 329
线段树存储区间信息（起始位置 结束位置 左儿子指针 右儿子指针 区间最小值 懒标记） 懒标记：当前节点最小值已减去而该节点的儿子节点（如果有的话）还没有减去的值 在线处理 模拟 对于每份订单 在线段树上对区间值进行减法运算 递归深搜寻找需要更新的区间 处理区间时 如果当前不是叶子节点 则下传懒标记（儿子节点区间最小值减去当前节点懒标记 儿子节点懒标记加上当前节点懒标记） 回溯时用儿子节点的区间最小值更新父亲节点的区间最小值 对于一个区间 如果区间最小值小于0 则该订单无法满足 反之 则该订单可以被满足 所
线段树模板整理
歪歪T的拿金之路
04-10 7883
综述线段树的原理：将[1,n]分解成若干特定的子区间(数量不超过4*n),然后，将每个区间[L,R]都分解为少量特定的子区间，通过对这些少量子区间的修改或者统计，来实现快速对[L,R]的修改或者统计。 作用：对编号连续的一些点的区间信息进行修改或者统计操作 主要操作：区间查询、点更新、区间更新 时间复杂度：修改和统计的复杂度都是O(log(N))由原理可以看出线段树维护的信息必须满足区间加法
5.4训练总结线段树
mikeshizi1234的博客
06-15 827
主要讲了线段树，线段树究竟是什么呢？其实就是一棵不那么满的二叉树，他有一下几个特点。维护序列的区间信息，方便查询每一个结点都是一个区间二叉树的基本性质，每一个非叶子结点都有222个分叉。接下来总结他们的表示方式根节点表示为111，然后左儿子表示为2∗i2 \ast i2∗i，右儿子表示为2∗i12∗i1。我们可以看这张图叶子节点长度为111，没有左右儿子那么每一个结点需要存储的有哪些信息呢？分别如下：lrl,rlr。
线段树专项训练习题集
逐梦者
01-10 2177
ACM模版线段树专项训练开始了，网上找了找相关的训练题，但是没有找到好的集锦，也只好作罢，自己根据前辈们的博客整理出来一份习题集吧，想来一下子全部整理出来不如一道道尝试，一道道整理，这样子可以给不同的试题更好的定位，所以，从今天开始，陆陆续续会更新本习题集，希望对大家以及我自己有更好的帮助。更新结点，区间求和HDU 1166 敌兵布阵更新结点，区间最值HDU 1754 I Hate It
线段树和树状数组——北京大学暑期课《ACM/ICPC竞赛训练》
05-14
### 线段树与树状数组：北京大学暑期课《ACM/ICPC竞赛训练》 #### 线段树概述 线段树是一种高效的数据结构，主要用于处理区间查询和区间更新问题。它通过将一个大的区间细分成若干个较小的不重叠的子区间来实现...
算法的学习笔记—连续子数组的最大和
业精于勤，荒于嬉
08-29 1537
通过上述的动态规划方法，我们能够有效地解决连续子数组的最大和问题。该方法简单易懂，并且具有较高的效率，适合在大多数情况下使用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😁如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🤞。
递归、搜索与回溯算法
无聊_人的博客
08-29 978
所谓的递归其实就是函数自己调用自己的情况。
7-7 数组中能被5整除的数的和
Virgo_616的博客
08-26 911
在一维数组中有10个整数，求出其中能被5整除的所有数的和。
力扣（无重叠区间）
yyssas的博客
08-29 1015
先按照左侧数字排序，然后对于i位置和i+1位置，如果i位置右侧数字大于i+1位置左侧数字，则说明这两个区间有重叠，则需要移除更可能和后面重叠的那一个，因为排序是按照左边从小到大排序的，所以左边一定是小的，此时要关注的就是右边，也就是选择i和i+1右侧更小的那个，即右侧大的那个删除。一直到右侧小于k的左侧停止，此时剩下的一定是不会重叠的那个。需要移除区间的最小数量，使剩余区间互不重叠。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 1148
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
C语言刷题日记(附详解)(2)
ixiaotang_的博客
08-24 3503
你所厌恶的今天，是昨天死去之人奢望的明天。你所浪费的现在，是未来的你回不去的曾经。时间如此宝贵，作为学生，学习就是我们的职责，那么不要懈怠！让我们开始今天的学习吧！
【算法】深入浅出聚类算法：原理、应用与Java实现
一个不断前行的程序者
08-26 2263
聚类算法是一种将数据集中的对象自动划分为多个子集的算法。每个子集称为一个簇，簇内的对象具有较高的相似度，而簇与簇之间的相似度较低。聚类算法的主要目的是发现数据中的自然结构，而不是通过已知的类别标签。本文介绍了聚类算法的原理、应用场景以及如何在Java中实现一个简单的聚类算法。通过聚类算法，我们可以发现数据集中的自然结构，有助于更好地理解数据。在实际应用中，可以根据具体需求选择合适的聚类算法。希望本文能够帮助读者更好地理解和应用聚类算法。
树上dp+分组背包类问题
最新发布
2301_80475191的博客
08-29 667
今天也是无意间看到了一个树上dp+分组背包类的问题，有些难度的，不好想的嘞，话不多说直接看题。
北京大学ACM线段树与树状数组讲解
在ACM/ICPC竞赛训练中，理解和掌握线段树和树状数组是非常关键的，因为它们可以高效地处理大量区间操作的问题，是解决许多算法题目的有效手段。通过深入学习和实践，可以提升算法能力，提高解决实际问题的效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值