• 线段树的板子和题目


    1.单点修改,区间求和

    #include<iostream>
    #include<algorithm>
    using namespace std;
    typedef long long ll;
    const int maxn=1e6+100;
    struct node{
        int l,r;
        ll s;
    }tree[maxn];
    int a[maxn];
    void push_up(int p){
        tree[p].s=tree[p*2].s+tree[p*2+1].s;
    }
    void build(int p,int l,int r){//p为当前节点编号,x,y为区间的左右端点 ,v是权值 
        tree[p].l=l;
        tree[p].r=r;
    /*节点 
                1
            2       3
         4    5   6    7
    */
    /*
                     [1,13]
                     
            [1,7]             [8,13]
            
       [1,4]     [5,7]  [8,10]     [11,13]
       
    [1,2]  [3,4].......  
    
    */ 
    
        if(l==r){
            tree[p].s=a[l];
            return ; 
        }
        int mid=(l+r)/2;
        build(p*2,l,mid);
        build(p*2+1,mid+1,r);
        push_up(p);    
    } 
    void update(int p,int x,int k){
        int L=tree[p].l,R=tree[p].r;
        if(L==R){
            tree[p].s+=k;
            return ;
        }
        if(x<=tree[p*2].r){//左交点 
            update(p*2,x,k);
        }
        else{
            update(p*2+1,x,k);
        }
        push_up(p);
    }
    // l   r
    ll query(int p,int l,int r){
        int L=tree[p].l,R=tree[p].r;
        ll ans=0;
        if(R<l||L>r){
            return 0;
        }
        if(l<=L&&R<=r){
            return tree[p].s;
        }
        if(tree[p*2].r>=l){//当前子左节点 
            ans+=query(p*2,l,r);
        }
        if(tree[p*2+1].l<=r){//当前子右节点 
            ans+=query(p*2+1,l,r);
        }
        return ans;
    }
    int main(){
        int t;
        cin>>t;
        int kase=1;
        while(t--){
            int n;
            cin>>n;
            for(int i=1;i<=n;i++){
                cin>>a[i];
            }
            build(1,1,n);
            printf("Case %d:
    ",kase++);
            char str[10];
            int l,r;
            while(scanf("%s",str)){
                if(str[0]=='E'){
                    break;
                }
                scanf("%d%d",&l,&r);
                if(str[0]=='Q'){
                    ll z=query(1,l,r);
                    printf("%lld
    ",z);
                }
                else if(str[0]=='A'){
                    update(1,l,r);
                }
                else if(str[0]=='S'){
                    update(1,l,-r);
                }
            }
        } 
        return 0;
    } 
    View Code

    2.区间修改,区间求和

    #include<iostream>
    #include<algorithm>
    using namespace std;
    typedef long long ll;
    const int maxn=3e6+100;
    struct node{
        ll l,r;
        ll s;
        ll lazy;
    }t[maxn];
    ll a[maxn];
    int n,m;
    void push(int p){
        t[2*p].lazy+=t[p].lazy;//下传标记 
        t[2*p].s+=1ll*(t[2*p].r-t[2*p].l+1)*t[p].lazy;
        
        t[2*p+1].lazy+=t[p].lazy;
        t[2*p+1].s+=1ll*(t[2*p+1].r-t[2*p+1].l+1)*t[p].lazy;
        
        t[p].lazy=0;//还原标记 
    }
    void build(int p,int l,int r){
        t[p].l=l;
        t[p].r=r;
        if(l==r){
            t[p].s=a[l];
            return ;
        }
        int mid=(l+r)/2;
        build(2*p,l,mid);
        build(2*p+1,mid+1,r);
        t[p].s=t[2*p].s+t[2*p+1].s;
    } 
    void update(int p,int l,int r,ll k){
        int L=t[p].l,R=t[p].r;
        if(L>=l&&R<=r){
            t[p].s+=1ll*(R-L+1)*k;
            t[p].lazy+=k;
            return ;
        }
        push(p);
        if(l<=t[2*p].r){
            update(2*p,l,r,k);
        } 
        if(r>=t[2*p+1].l){
            update(2*p+1,l,r,k);
        }
        t[p].s=t[2*p].s+t[2*p+1].s; 
    }
    ll query(int p,int l,int r){ 
        int L=t[p].l,R=t[p].r; 
        if(L>r||R<l){
            return 0; 
        }
        if(l<=L&&r>=R){
            return t[p].s;
        }
        ll ans=0;
        push(p);
        if(l<=t[2*p].r){
            ans+=query(2*p,l,r);
        }
        if(r>=t[2*p+1].l){
            ans+=query(2*p+1,l,r);
        }
        return ans; 
    }
    int main(){
        cin>>n>>m;
        for(int i=1;i<=n;i++){
            scanf("%lld",&a[i]);
        }
        build(1,1,n);
        char str[10];
        int l,r;
        ll k;
        for(int i=1;i<=m;i++){
            scanf("%s",str);
            if(str[0]=='Q'){
                scanf("%d%d",&l,&r); 
                ll ans=query(1,l,r);
                printf("%lld
    ",ans);
            }
            else if(str[0]=='C'){
                scanf("%d%d%lld",&l,&r,&k);
                update(1,l,r,k);
            }
        }
        return 0;
    }
    View Code

    4.区间乘法和加法

    要两个懒惰标记jia,cheng

    当进行乘法操作的时候,加法标记也要乘k,就是+k*jia;

    下传加法标记的时候就是要用(子节点加法标记*父节点的加发标记+父节点的加法标记)

    下传乘法标记的时候就是(子节点的乘法标记*父节点的乘法标记)

    区间和的话就是加法标记*区间长度+子结点的加法标记*夫节点的乘法标记

    下传标记只是为了下一次操作,和区间求和不一样

    void cheng(ll x,ll l,ll r,ll d)
    {
        if (l<=t[x].l&&t[x].r<=r)//全部包括 
    {//三个值全部都要乘上去
    
            t[x].date=t[x].date*d%mod;
            t[x].laze=t[x].laze*d%mod;
            t[x].mul=t[x].mul*d%mod;
        } else
        {
            pushdown(x);//向下传递值 
            ll mid=(t[x].l+t[x].r)/2;
            if (l<=mid) cheng(x*2,l,r,d);//继续往下搜
            if (r>mid)cheng(x*2+1,l,r,d);
            t[x].date=(t[x*2+1].date+t[x*2].date)%mod;//更新sum 
        }
        return;
    }
    void pushdown(ll x)
    {
        t[x*2].laze=(t[x*2].laze*t[x].mul+t[x].laze)%mod;//
        t[x*2+1].laze=(t[x*2+1].laze*t[x].mul+t[x].laze)%mod;
        t[x*2].mul=(t[x*2].mul*t[x].mul)%mod;//
        t[x*2+1].mul=(t[x*2+1].mul*t[x].mul)%mod;
        t[x*2].date=(t[x].laze*(t[x*2].r-t[x*2].l+1)%mod+t[x*2].date*t[x].mul%mod)%mod;//求和 
        t[x*2+1].date=(t[x].laze*(t[x*2+1].r-t[x*2+1].l+1)%mod+t[x*2+1].date*t[x].mul%mod)%mod;//求和 
        t[x].laze=0;t[x].mul=1; 
    }
    #include<cstdio>
    #include<iostream>
    #include<algorithm>
    #include<map> 
    #include <math.h>
    using namespace std;
    typedef long long ll;
    const int maxn=1e6+10;
    ll a[maxn]; 
    ll mod;
    inline int read()
    {
        int x=0;char ch=getchar();
        while(ch<'0'||ch>'9')ch=getchar();
        while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
        return x;
    }
    struct node{
        ll l;//l:左节点 r:右节点 
        ll r;//dat:当前节点的值 laze_tag:懒标记,记录改变的值,递归传值 
        ll date,laze;
        ll mul;
    }t[maxn];//四倍n 
    //void f(ll p,ll m,ll k){ 
    //    t[p].laze=(t[p].laze*m+k)%mod;//懒标记传递
    //    t[p].date+=(k*(t[p].r-t[p].l+1))%mod;//当前值加上所有节点总数*值     
    //}
    //void fmul(ll p,ll k){
    //    t[p].mul=(t[p].mul*k)%mod;
    //    t[p].date+=(t[p].date*k)%mod;
    //}
    //void pushdown(ll p){//传懒标 
    //    f(p*2,t[p].mul,t[p].laze);
    //    f(p*2+1,t[p].mul,t[p].laze);
    //    fmul(p*2,t[p].mul);
    //    fmul(p*2+1,t[p].mul);
    //     //将懒标记的值传给下面的左右儿子节点
    //    t[p].laze=0;
    //    t[p].mul=1;
    //    //复原懒标记 
    //}
    void pushdown(ll x)
    {
        t[x*2].laze=(t[x*2].laze*t[x].mul+t[x].laze)%mod;//
        t[x*2+1].laze=(t[x*2+1].laze*t[x].mul+t[x].laze)%mod;
        t[x*2].mul=(t[x*2].mul*t[x].mul)%mod;//
        t[x*2+1].mul=(t[x*2+1].mul*t[x].mul)%mod;
        t[x*2].date=(t[x].laze*(t[x*2].r-t[x*2].l+1)%mod+t[x*2].date*t[x].mul%mod)%mod;//求和 
        t[x*2+1].date=(t[x].laze*(t[x*2+1].r-t[x*2+1].l+1)%mod+t[x*2+1].date*t[x].mul%mod)%mod;//求和 
        t[x].laze=0;t[x].mul=1; 
    }
    void js(ll p,ll l,ll r){//建树 
        t[p].l=l;//记录左右节点 
        t[p].r=r;
        t[p].laze=0; 
        t[p].mul=1;
        if(l==r){//到达底部返回值 
            t[p].date=a[l];
            return ;
        }
        ll mid=(l+r)/2;//中点
        js(p*2,l,mid);
        js(p*2+1,mid+1,r);
            //递归初始化
        t[p].date=(t[p*2].date+t[p*2+1].date)%mod;
          //加上左右儿子节点 
    }
    void pushs(ll p,ll l,ll r,ll v){//区间加减
        if(t[p].l>=l&&t[p].r<=r){//如果区间被包含就修改并打上懒标记 
            t[p].date+=v*(t[p].r-t[p].l+1)%mod;//加上所有值
            t[p].laze+=v%mod;//懒标记修改 
            return ;
        }
        pushdown(p);//查询懒标记,因为下面要递归 
        ll mid=(t[p].l+t[p].r)/2;//取中点
        if(l<=mid){
            pushs(p*2,l,r,v);//修改左边 
        }
        if(r>mid){
            pushs(p*2+1,l,r,v);//修改右边  
        }
        t[p].date=(t[p*2].date+t[p*2+1].date)%mod;//回溯时加上左右儿子节点的值 
    } 
    //void cheng(ll p,ll l,ll r,ll w){
    //    if(l<=t[p].l&&t[p].r<=r){
    //        t[p].date=t[p].date*w%mod;
    //        t[p].laze=t[p].laze*w%mod;
    //        t[p].mul=t[p].mul*w%mod;
    //        return ;
    //    }
    //    pushdown(p);
    //    ll mid=(t[p].l+t[p].r)/2;//取中点
    //    if(l<=mid){
    //        pushs(p*2,l,r,w);//修改左边 
    //    }
    //    if(r>mid){
    //        pushs(p*2+1,l,r,w);//修改右边  
    //    }
    //    t[p].date=(t[p*2].date+t[p*2+1].date)%mod;
    //}
    void cheng(ll x,ll l,ll r,ll d)
    {
        if (l<=t[x].l&&t[x].r<=r)//全部包括 
    {//三个值全部都要乘上去
    
            t[x].date=t[x].date*d%mod;
            t[x].laze=t[x].laze*d%mod;
            t[x].mul=t[x].mul*d%mod;
        } else
        {
            pushdown(x);//向下传递值 
            ll mid=(t[x].l+t[x].r)/2;
            if (l<=mid) cheng(x*2,l,r,d);//继续往下搜
            if (r>mid)cheng(x*2+1,l,r,d);
            t[x].date=(t[x*2+1].date+t[x*2].date)%mod;//更新sum 
        }
        return;
    }
    ll outt(ll p,ll l){//单点查询 
        if(t[p].l==l&&t[p].r==l){//找到目标点就返回 
            return t[p].date%mod;
        }
        pushdown(p);//先回复懒标记的值再传递,因为下面可能递归(要判断是否到了底部,就是这里出了问题QwQ)
        ll mid=(t[p].l+t[p].r)/2;//记录中点
        if(l<=mid) return outt(p*2,l)%mod;//找左边
        if(l>mid) return outt(p*2+1,l)%mod;//找右边 
    }
    ll check(ll p,ll l,ll r,ll x,ll y){
        if(l>=x&&r<=y){
            return t[p].date%mod;
        }
        ll mid=(t[p].l+t[p].r)/2;
        ll ans=0;
        pushdown(p);
        if(x<=mid){
            ans+=check(p*2,l,mid,x,y)%mod; 
        }
        if(mid<y){
            ans+=check(p*2+1,mid+1,r,x,y)%mod;
        }
        return ans%mod;
    } 
    int main(){
        int n,m; 
           cin>>n>>m>>mod;//读入 
        for(int i=1;i<=n;i++)
            scanf("%lld",&a[i]); 
        js(1,1,n);//建树
        ll z;
        ll x,y,w; 
        for(int i=1;i<=m;i++){
            scanf("%lld",&z);
            if(z==1){
                scanf("%lld%lld%lld",&x,&y,&w);
                cheng(1,x,y,w);
            }
            else if(z==2){
                scanf("%lld%lld%lld",&x,&y,&w);
                pushs(1,x,y,w);
            }
            else if(z==3){
                scanf("%lld%lld",&x,&y);
                ll ans=check(1,1,n,x,y)%mod;
                printf("%lld
    ",ans%mod);
            }
        }
        return 0;//华丽丽的结束,可以A掉树状数组2了!!! 
    }
    完整代码1
    #include<iostream>
    #include<algorithm>
    using namespace std;
    typedef long long ll;
    const int maxn=1e6+100;
    int n,m;
    ll mod;
    struct node{
        int l,r;
        ll sum;
        ll lazyj;
        ll lazyc;
    }t[maxn];
    ll a[maxn]; 
    void push_up(int p){
        t[2*p].lazyj=((t[2*p].lazyj*t[p].lazyc)%mod+t[p].lazyj)%mod;
        t[2*p+1].lazyj=((t[2*p+1].lazyj*t[p].lazyc)%mod+t[p].lazyj)%mod;
        
        t[2*p].lazyc=(t[2*p].lazyc*t[p].lazyc)%mod;
        t[2*p+1].lazyc=(t[2*p+1].lazyc*t[p].lazyc)%mod;
        
        t[2*p].sum=(t[p].lazyj*(t[2*p].r-t[2*p].l+1)%mod+(t[2*p].sum*t[p].lazyc)%mod)%mod;
        t[2*p+1].sum=(t[p].lazyj*(t[2*p+1].r-t[2*p+1].l+1)%mod+(t[2*p+1].sum*t[p].lazyc)%mod)%mod;
        
        t[p].lazyj=0;
        t[p].lazyc=1;
        
    }
    void jiafa(int p,int l,int r,ll k){
        int L=t[p].l,R=t[p].r;
        if(L>=l&&R<=r){
            t[p].sum+=k*(t[p].r-t[p].l+1)%mod;
            t[p].lazyj+=k%mod;
            return ;
        }
        push_up(p);
        if(l<=t[2*p].r){
            jiafa(2*p,l,r,k);
        } 
        if(r>=t[2*p+1].l){
            jiafa(2*p+1,l,r,k);
        }
        t[p].sum=(t[2*p].sum+t[2*p+1].sum)%mod;
    }
    void chengfa(int p,int l,int r,ll k){
        int L=t[p].l,R=t[p].r;
        if(L>=l&&R<=r){
            t[p].sum=(t[p].sum*k)%mod;
            t[p].lazyc=(t[p].lazyc*k)%mod;
            t[p].lazyj=(t[p].lazyj*k)%mod; 
            return ;
        }
        push_up(p);
        if(l<=t[2*p].r){
            chengfa(2*p,l,r,k);
        } 
        if(r>=t[2*p+1].l){
            chengfa(2*p+1,l,r,k);
        }
        t[p].sum=(t[2*p].sum+t[2*p+1].sum)%mod;
    }
    void jianshu(int p,int l,int r){
        t[p].l=l,t[p].r=r;    
        t[p].lazyc=1;
        t[p].lazyj=0;
        if(l==r){
            t[p].sum=a[l];
            return ;
        }
        int mid=(l+r)/2;
        jianshu(p*2,l,mid);
        jianshu(p*2+1,mid+1,r);
        t[p].sum=(t[2*p].sum+t[2*p+1].sum)%mod;
    } 
    ll query(int p,int l,int r){
        int L=t[p].l,R=t[p].r;
        if(L>=l&&R<=r){
            return t[p].sum%mod;
        }    
        ll ans=0;
        push_up(p);
        if(l<=t[2*p].r){
            ans+=query(2*p,l,r)%mod;
        }
        if(r>=t[2*p+1].l){
            ans+=query(2*p+1,l,r)%mod;
        }
        return ans%mod;
    }
    int main(){
        cin>>n>>m>>mod;
        for(int i=1;i<=n;i++){
            cin>>a[i];
        }
        jianshu(1,1,n);
        int op,l,r;
        ll k;
        for(int i=1;i<=m;i++){
            scanf("%d",&op);
            if(op==1){
                scanf("%d%d%lld",&l,&r,&k);
                chengfa(1,l,r,k); 
            }
            else if(op==2){
                scanf("%d%d%lld",&l,&r,&k);
                jiafa(1,l,r,k);
            }
            else{
                scanf("%d%d",&l,&r);
                ll ans=query(1,l,r);
                printf("%lld
    ",ans%mod);
            }
        }
        return 0;
    }
    完整代码2

    例题1:

    例题2:就是把区间中的值变成同一个值,这个还带区间加法,区间重赋值,区间求和(就是让区间中的值先乘上0最加上某一个值)

    #include<iostream>
    #include<algorithm>
    using namespace std;
    typedef long long ll;
    const int maxn=1e6+100;
    const int mod=20007; 
    int n,m;
    struct node{
        int l,r;
        ll sum;
        ll lazyj;
        ll lazyc;
    }t[maxn];
    ll a[maxn]; 
    void push_up(int p){
        t[2*p].lazyj=((t[2*p].lazyj*t[p].lazyc)%mod+t[p].lazyj)%mod;
        t[2*p+1].lazyj=((t[2*p+1].lazyj*t[p].lazyc)%mod+t[p].lazyj)%mod;
        
        t[2*p].lazyc=(t[2*p].lazyc*t[p].lazyc)%mod;
        t[2*p+1].lazyc=(t[2*p+1].lazyc*t[p].lazyc)%mod;
        
        t[2*p].sum=(t[p].lazyj*(t[2*p].r-t[2*p].l+1)%mod+(t[2*p].sum*t[p].lazyc)%mod)%mod;
        t[2*p+1].sum=(t[p].lazyj*(t[2*p+1].r-t[2*p+1].l+1)%mod+(t[2*p+1].sum*t[p].lazyc)%mod)%mod;
        
        t[p].lazyj=0;
        t[p].lazyc=1;
        
    }
    void jiafa(int p,int l,int r,ll k){
        int L=t[p].l,R=t[p].r;
        if(L>=l&&R<=r){
            t[p].sum+=k*(t[p].r-t[p].l+1)%mod;
            t[p].lazyj+=k%mod;
            return ;
        }
        push_up(p);
        if(l<=t[2*p].r){
            jiafa(2*p,l,r,k);
        } 
        if(r>=t[2*p+1].l){
            jiafa(2*p+1,l,r,k);
        }
        t[p].sum=(t[2*p].sum+t[2*p+1].sum)%mod;
    }
    void chengfa(int p,int l,int r,ll k){
        int L=t[p].l,R=t[p].r;
        if(L>=l&&R<=r){
            t[p].sum=(t[p].sum*k)%mod;
            t[p].lazyc=(t[p].lazyc*k)%mod;
            t[p].lazyj=(t[p].lazyj*k)%mod; 
            return ;
        }
        push_up(p);
        if(l<=t[2*p].r){
            chengfa(2*p,l,r,k);
        } 
        if(r>=t[2*p+1].l){
            chengfa(2*p+1,l,r,k);
        }
        t[p].sum=(t[2*p].sum+t[2*p+1].sum)%mod;
    }
    void jianshu(int p,int l,int r){
        t[p].l=l,t[p].r=r;    
        t[p].lazyc=1;
        t[p].lazyj=0;
        if(l==r){
            t[p].sum=a[l];
            return ;
        }
        int mid=(l+r)/2;
        jianshu(p*2,l,mid);
        jianshu(p*2+1,mid+1,r);
        t[p].sum=(t[2*p].sum+t[2*p+1].sum)%mod;
    } 
    ll query(int p,int l,int r){
        int L=t[p].l,R=t[p].r;
        if(L>=l&&R<=r){
            return t[p].sum%mod;
        }    
        ll ans=0;
        push_up(p);
        if(l<=t[2*p].r){
            ans+=query(2*p,l,r)%mod;
        }
        if(r>=t[2*p+1].l){
            ans+=query(2*p+1,l,r)%mod;
        }
        return ans%mod;
    }
    int main(){
        cin>>n>>m;
        for(int i=1;i<=n;i++){
            a[i]=0;
        }
        jianshu(1,1,n);
        int op,l,r;
        ll k;
        for(int i=1;i<=m;i++){
            scanf("%d",&op);
            if(op==1){
                scanf("%d%d%lld",&l,&r,&k);
                chengfa(1,l,r,0);
                jiafa(1,l,r,k); 
            }
            else if(op==2){
                scanf("%d%d%lld",&l,&r,&k);
                jiafa(1,l,r,k);
            }
            else{
                scanf("%d%d",&l,&r);
                ll ans1=query(1,l,r); 
                cout<<ans1%mod<<endl;
            } 
        }
        return 0;
    }

    区间重赋值不带区间加法(直接通过改变懒标就行)

    传送门

    #include<iostream>
    #include<algorithm>
    using namespace std;
    const int maxn=1e6+100;
    struct node{
        int l,r;
        int dazy;
        int sum;
    }t[maxn];
    void push_up(int p){
        if(t[p].dazy){//必须的 
            t[2*p].dazy=t[p].dazy;
            t[2*p+1].dazy=t[p].dazy;
            t[2*p].sum=(t[2*p].r-t[2*p].l+1)*t[p].dazy;
            t[2*p+1].sum=(t[2*p+1].r-t[2*p+1].l+1)*t[p].dazy;
            t[p].dazy=0;
        }
    }
    void jianshu(int p,int l,int r){
        t[p].l=l;
        t[p].r=r;
        t[p].dazy=0;//注意 
        if(l==r){
            t[p].sum=1;
            return ;    
        }
        int mid=(l+r)/2;
        jianshu(2*p,l,mid);
        jianshu(2*p+1,mid+1,r);
        t[p].sum=t[2*p+1].sum+t[2*p].sum;
    }
    void update(int p,int l,int r,int k){
        int L=t[p].l,R=t[p].r;
        if(L>=l&&R<=r){
            t[p].dazy=k;
            t[p].sum=(R-L+1)*k;
            return ;
        }
        push_up(p);
        if(l<=t[2*p].r){
            update(2*p,l,r,k);
        }
        if(r>=t[2*p+1].l){
            update(2*p+1,l,r,k);
        }
        t[p].sum=t[2*p+1].sum+t[2*p].sum;
    }
    int query(int p,int l,int r){
        int L=t[p].l,R=t[p].r;
        if(L>=l&&R<=r){
            return t[p].sum;
        }
        push_up(p);
        int ans=0;
        if(l<=t[2*p].r){
            ans+=query(2*p,l,r);
        }
        if(r>=t[2*p+1].l){
            ans+=query(2*p+1,l,r);
        }
        return ans;
    }
    int main(){
        int t,n,m;
        scanf("%d",&t);
        int kase=0;
        while(t--){
            scanf("%d%d",&n,&m);
            jianshu(1,1,n);
            int l,r,k;
            for(int i=1;i<=m;i++){
                scanf("%d%d%d",&l,&r,&k);
                update(1,l,r,k);
            }
            int ans=query(1,1,n);
            printf("Case %d: The total value of the hook is %d.
    ",++kase,ans); 
        }
    }
    View Code

    查询区间最大值和最小值(只是查询)

    #include<iostream>
    #include<algorithm>
    #include<math.h> 
    #include<cstring>
    using namespace std;
    const int maxn=1e6+100;
    struct node{
        int l,r;
        int ma,mi;
    }t[maxn];
    int a[maxn];
    int max(int a,int b){
        if(a>b){
            return a;
        }
        return b;
    }
    int min(int a,int b){
        if(a>b){
            return b;
        }
        return a;
    }
    void jianshu(int p,int l,int r){
        t[p].l=l;
        t[p].r=r;
        if(l==r){
            t[p].mi=a[l];
            t[p].ma=a[l];
            return ;
        } 
        int mid=(l+r)/2;
        jianshu(2*p,l,mid);
        jianshu(2*p+1,mid+1,r);
        t[p].ma=max(t[2*p].ma,t[2*p+1].ma);
        t[p].mi=min(t[2*p].mi,t[2*p+1].mi);
    }
    int query1(int p,int l,int r){//最小值 
        int L=t[p].l,R=t[p].r;
        if(L>=l&&R<=r){
            return t[p].mi;
        } 
        if(r<=t[2*p].r){
            return query1(2*p,l,r);
        }
        else if(l>=t[2*p+1].l){
            return query1(2*p+1,l,r);
        }
        else{
            return min(query1(2*p,l,r),query1(2*p+1,l,r));
        }
    }
    int query2(int p,int l,int r){
        int L=t[p].l,R=t[p].r;
        if(L>=l&&R<=r){
            return t[p].ma;
        } 
        if(r<=t[2*p].r){
            return query2(2*p,l,r);
        }
        else if(l>=t[2*p+1].l){
            return query2(2*p+1,l,r);
        }
        else{
            return max(query2(2*p,l,r),query2(2*p+1,l,r));
        }
    }
    int main(){
        int n,m;
        cin>>n>>m;
        for(int i=1;i<=n;i++){
            cin>>a[i];
        }
        jianshu(1,1,n);
        int l,r;
        for(int i=1;i<=m;i++){
            scanf("%d%d",&l,&r);
            //cout<<query2(1,l,r)<<" "<<query1(1,l,r)<<endl;
            int ans=query2(1,l,r)-query1(1,l,r);
            printf("%d
    ",ans);
        }
    } 
    View Code

    区间最大值(带修改)

    #pragma GCC optimize(1)
    #pragma GCC optimize(2)
    #pragma GCC optimize(3,"Ofast","inline")
    #include<iostream>
    #include<algorithm>
    using namespace std;
    const int maxn=1e6+100; 
    struct node{
        int l,r;
        int m;
    }t[maxn];
    int a[maxn];
    int n,m;
    void jianshu(int p,int l,int r){
        t[p].l=l;
        t[p].r=r;
        if(l==r){
            t[p].m=a[l];
            return ;
        }
        int mid=(l+r)/2;
        jianshu(2*p,l,mid);
        jianshu(2*p+1,mid+1,r);
        t[p].m=max(t[2*p].m,t[2*p+1].m);
    }
    void update(int p,int pos,int k){
        if(t[p].l==t[p].r){
            t[p].m=k;
            return ;
        }
        if(pos<=t[2*p].r){
            update(2*p,pos,k);
        } 
        else{
            update(2*p+1,pos,k);
        }
        t[p].m=max(t[2*p].m,t[2*p+1].m);
    }
    int query(int p,int l,int r){
        if(l<=t[p].l&&r>=t[p].r){
            return t[p].m;
        } 
        if(r<=t[2*p].r){
            return query(2*p,l,r);
        }
        else if(l>=t[2*p+1].l){
            return query(2*p+1,l,r);
        }
        else{
            return max(query(2*p,l,r),query(2*p+1,l,r));
        }
    }
    int main(){
        while(~scanf("%d%d",&n,&m)){
            char str[10];
            for(int i=1;i<=n;i++){
                cin>>a[i];
            }
            jianshu(1,1,n);
            int l,r;
            int k;
            for(int i=1;i<=m;i++){
                scanf("%s",str);
                if(str[0]=='Q'){
                    scanf("%d%d",&l,&r);
                    int ans=query(1,l,r);
                    printf("%d
    ",ans); 
                }
                else if(str[0]=='U'){
                    scanf("%d%d",&l,&k);
                    update(1,l,k);
                }
            }
        }
    } 
    View Code

    区间开根号

    2^63只需要开 6 次根号就会到 1 . 所以,即使暴力将每个数都更新到 

    #pragma GCC optimize(1)
    #pragma GCC optimize(2)
    #pragma GCC optimize(3,"Ofast","inline")
    #include<iostream>
    #include<algorithm>
    using namespace std;
    typedef long long ll;
    template <typename Tp>
    void read(Tp &x){//read(n);
        x=0;char ch=1;int fh;
        while(ch!='-'&&(ch>'9'||ch<'0')){
            ch=getchar();
        }
        if(ch=='-'){
            fh=-1;ch=getchar();
        }else fh=1;
        while(ch>='0'&&ch<='9'){
            x=(x<<1)+(x<<3)+ch-'0';ch=getchar();
        }
        x*=fh;
    }
    const int maxn=1e6+100; 
    struct node{
        int l,r;
        ll sum;
    }t[maxn];
    ll a[maxn];
    void jianshu(int p,int l,int r){
        t[p].l=l;
        t[p].r=r;
        if(l==r){
            t[p].sum=a[l];
            return ;
        }
        int mid=(t[p].l+t[p].r)>>1;
        jianshu(p<<1,l,mid);
        jianshu(p<<1|1,mid+1,r);
        t[p].sum=t[p<<1].sum+t[p<<1|1].sum; 
    }
    void update(int p,int l,int r){
        int L=t[p].l,R=t[p].r;
        if(L==R){
            t[p].sum=sqrt(t[p].sum);
            return ;
        } 
        if((R-L+1)>=t[p].sum){//区间内都是1 重点 
            return ;
        } 
        if(l<=t[p<<1].r){
            update(p<<1,l,r);
        } 
        if(r>=t[p<<1|1].l){
            update(p<<1|1,l,r);
        } 
        t[p].sum=t[p<<1].sum+t[p<<1|1].sum; 
    } 
    ll query(int p,int l,int r){
        if(t[p].l>=l&&t[p].r<=r){
            return t[p].sum;
        }
        ll ans=0;
        if(l<=t[p<<1].r){
            ans+=query(p<<1,l,r);
        }
        if(r>=t[p<<1|1].l){
            ans+=query(p<<1|1,l,r);
        }
        return ans;
    }
    int main(){
        int n,m;
        int kase=1;
        while(~scanf("%d",&n)){
            for(int i=1;i<=n;i++){
                scanf("%lld",&a[i]);
            }     
            jianshu(1,1,n);
            scanf("%d",&m); 
            printf("Case #%d:
    ",kase++);
            int op,l,r;
            for(int i=1;i<=m;i++){
                scanf("%d%d%d",&op,&l,&r);
                if(r<l){
                    swap(l,r);
                }            
                if(op==0){
                    update(1,l,r);
                }
                else{
                    printf("%lld
    ",query(1,l,r));
                }
            }
            printf("
    ");
        }
        return 0; 
    } 
    View Code

    dfs序+线段树

    传送门

    题目大意,就是说有一颗树,如果把他的父节点改为一个树,那么他的子节点也会跟着变,为你某一个节点的数

    就是先对这个树求一个dfs序,然后就是线段树的区间修改,和单点查询了

    #include<iostream>
    #include<algorithm>
    #include<cstring> 
    using namespace std;
    const int maxn=1e6+100;
    typedef long long ll;
    template <typename Tp>
    void read(Tp &x){//read(n);
        x=0;char ch=1;int fh;
        while(ch!='-'&&(ch>'9'||ch<'0')){
            ch=getchar();
        }
        if(ch=='-'){
            fh=-1;ch=getchar();
        }else fh=1;
        while(ch>='0'&&ch<='9'){
            x=(x<<1)+(x<<3)+ch-'0';ch=getchar();
        }
        x*=fh;
    }
    inline char read1()//字符串读入挂
    {
        register char ch=getchar();
        while(ch<'A'||ch>'M')ch=getchar();
        return ch;
    }
    struct node{
        int l,r;
        int val;
    }t[maxn]; 
    struct tu{
        int next;
        int to;
    }edge[maxn];
    int head[maxn],cnt;
    int index=0;
    int s[maxn],e[maxn];
    bool vis[maxn];
    void add(int u,int v){
        edge[cnt].to=v;
        edge[cnt].next=head[u];
        head[u]=cnt++;
    }
    void dfs(int u){
        s[u]=++index;
        for(int i=head[u];~i;i=edge[i].next){
            int v=edge[i].to;
            dfs(v);
        }
        e[u]=index;
    }
    void jianshu(int p,int l,int r){
        t[p].l=l;
        t[p].r=r;
        t[p].val=-1;
        if(l==r){
            return ;
        }
        int mid=(t[p].l+t[p].r)/2;
        jianshu(2*p,l,mid);
        jianshu(2*p+1,mid+1,r);
    }
    void push_up(int p){
        if(t[p].val>=0){
            t[2*p].val=t[p].val;
            t[2*p+1].val=t[p].val;
            t[p].val=-1;
        }
    }
    void update(int p,int l,int r,int k){
        if(l<=t[p].l&&t[p].r<=r){
            t[p].val=k;
            return ;
        }
        push_up(p); 
        if(l<=t[2*p].r){
            update(2*p,l,r,k);
        }
        if(r>=t[2*p+1].l){
            update(2*p+1,l,r,k);
        }
    //    if(r<=t[2*p].r){
    //        update(2*p,l,r,k);
    //    } 
    //    else if(l>=t[2*p+1].l){
    //        update(2*p+1,l,r,k);
    //    }
    //    else{
    //        update(2*p,l,r,k);
    //        update(2*p+1,l,r,k);
    //    }
    }
    int query(int p,int x){
        if(t[p].l==t[p].r){
            return t[p].val;
        }
        push_up(p);
        if(x<=t[2*p].r){
            return query(2*p,x);
        } 
        else{
            return query(2*p+1,x);
        }
    }
    int main(){
        int t;
        cin>>t;
        int kase=0;
        while(t--){
            memset(head,-1,sizeof(head));
            memset(vis,false,sizeof vis);
            cnt=0;
            index=0;
            int n;
            cin>>n;
            int u,v;
            for(int i=1;i<=n-1;i++){
                scanf("%d%d",&u,&v);//v是父节点 
                add(v,u);
                vis[u]=true;
            }
            for(int i=1;i<=n;i++){
                if(!vis[i]){
                    dfs(i);
                    break;
                }
            }
            jianshu(1,1,n); 
            char str[10];
            int x,k; 
            int m;
            read(m);
            printf("Case #%d:
    ",++kase);
            for(int i=1;i<=m;i++){
                scanf("%s",str);
                if(str[0]=='C'){
                    scanf("%d",&x);
                    int ans=query(1,s[x]);
                    printf("%d
    ",ans); 
                }
                else if(str[0]=='T'){
                    scanf("%d%d",&x,&k);
                    update(1,s[x],e[x],k);
                }
            }
            
        }
    } 
    View Code

    二分+线段树

    传送门

    参考博客

    有两个操作

    1。选择一个瓶子A,遍历A到n-1(下标是从0开始的)如果遇到瓶子就放一朵花,只到花放完或者没有瓶子了。让你输出放花的

    开始和结束位置,如果没有放花就是出一行字母

    2.就是把A-B中的花都丢弃

    这个题目很巧妙,就是线段树中的sum维护的区间内空瓶子的数量,在一个区间内他是单调的,所以可以二分找这个位置

    而这个懒惰标记有三种状态就是-1(初始状态),

    1标记为1时(把区间内的都清空)因为是t[2*p].sum=(t[2*p].r-t[2*p].l+1)*t[p].flag就都变空了,就是空瓶子为区间长度

    2.标记为0时(区间内的都放满)因为是t[2*p].sum=(t[2*p].r-t[2*p].l+1)*t[p].flag就都变满了,就是区间内的空瓶子为0

    #include<iostream>
    #include<algorithm>
    using namespace std;
    const int maxn=1e6+100;
    int n,m;
    struct node{
        int l;
        int r;
        int sum;//区间内空瓶的数量 
        int flag;//如果是-1就是初始状态,不能下传, 
    }t[maxn];
    /*
    1.标记为1时(把区间内的都清空)因为是t[2*p].sum=(t[2*p].r-t[2*p].l+1)*t[p].flag就都变空了,
    就是空瓶子为区间长度
    
    2.标记为0时(区间内的都放满)因为是t[2*p].sum=(t[2*p].r-t[2*p].l+1)*t[p].flag就都变满了,
    就是区间内的空瓶子为0
    */ 
    void build(int p,int l,int r){
        t[p].l=l,t[p].r=r;
        t[p].flag=-1;
        if(l==r){
            t[p].sum=1;
            return ;
        }
        int mid=(t[p].l+t[p].r)/2;
        build(2*p,l,mid);
        build(2*p+1,mid+1,r);
        t[p].sum=t[2*p].sum+t[2*p+1].sum;
    }
    void push_up(int p){
        if(t[p].flag!=-1){
            t[2*p].flag=t[2*p+1].flag=t[p].flag;
            
            t[2*p].sum=(t[2*p].r-t[2*p].l+1)*t[p].flag;
            t[2*p+1].sum=(t[2*p+1].r-t[2*p+1].l+1)*t[p].flag;
            t[p].flag=-1;
        }
    }
    void update(int p,int l,int r,int k){//区间修改 
        int L=t[p].l,R=t[p].r;
        if(l<=L&&r>=R){
            t[p].sum=(R-L+1)*k;
            t[p].flag=k;
            return ;
        }
        push_up(p);
        if(l<=t[2*p].r){
            update(2*p,l,r,k);    
        } 
        if(r>=t[2*p+1].l){
            update(2*p+1,l,r,k);
        } 
        t[p].sum=t[2*p].sum+t[2*p+1].sum;
    } 
    int query(int p,int l,int r){
        int L=t[p].l,R=t[p].r;
        if(l<=L&&r>=R){
            return t[p].sum;
        }
        push_up(p);
        int ans=0;
        if(l<=t[2*p].r){
            ans+=query(2*p,l,r);    
        } 
        if(r>=t[2*p+1].l){
            ans+=query(2*p+1,l,r);
        }  
        return ans;
    }
    int dive(int x,int num){//开始位置和要插花的个数 
        int l=x,r=n;//区间内空瓶子的数量是单调的 
        int ans;//所以能二分 
        while(l<=r){
            int mid=(l+r)/2;
            if(query(1,x,mid)>=num){
                ans=mid;
                r=mid-1;
            }
            else{
                l=mid+1;
            }
        }
        return ans; 
    }
    int main(){
        int kase;
        cin>>kase;
        while(kase--){
            scanf("%d%d",&n,&m);
            int op,l,r;
            build(1,1,n);
            for(int i=1;i<=m;i++){
                scanf("%d",&op);
                if(op==1){
                    int A,F;
                    scanf("%d%d",&A,&F);
                    A++;//序号加一, 
                    int cnt=query(1,A,n);//得到区间[A,n]中空花瓶的个数 
                    if(cnt==0){
                        printf("Can not put any one.
    ");
                    }
                    else{
                        int L=dive(A,1);//二分左端点(第一个能插花的位置)
                        int R=dive(A,min(F,cnt));
                        update(1,L,R,0);//将区间内的花瓶都装满,把flag=0,下传的时候就把子节点的sum变成0了
                        printf("%d %d
    ",L-1,R-1); 
                    }
                }
                else if(op==2){
                    int A,B;
                    scanf("%d%d",&A,&B);
                    A++;
                    B++;
                    printf("%d
    ",B-A+1-query(1,A,B));
                    update(1,A,B,1);
                }
            }
            printf("
    "); 
        }
         
    } 
    View Code
  • 相关阅读:
    C# 反射
    WPF之布局
    java网络编程中的BIO,NIO,AIO
    BIO的阻塞
    AttributeView的用法
    将linux文件中的tab更换为空格的三种方法
    安装nginx-ingress控制器,使用
    docker 搭建jenkins
    Manjaro 18.0.1 系统安装后值得看的两篇博客
    github创建自己的项目并进行推送
  • 原文地址:https://www.cnblogs.com/lipu123/p/13920210.html
Copyright © 2020-2023  润新知