线段树专题

最新推荐文章于 2024-09-24 16:02:20 发布

原创最新推荐文章于 2024-09-24 16:02:20 发布 · 472 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#algorithm

线段树&&树状数组专栏收录该内容

51 篇文章

订阅专栏

1000

#include<stdio.h>
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
#define ls (rt<<1)
#define rs (rt<<1|1)
#define mid ((l+r)>>1)
#define maxn 111111
int sum[maxn<<2];
int n,m,a,b,c;
char op[5];
void build(int rt,int l,int r){
    sum[rt]=0;
    if(l==r){
        scanf("%d",&sum[rt]);
        return ;
    }
    build(ls,l,mid);
    build(rs,mid+1,r);
    sum[rt]=sum[ls]+sum[rs];
}
void ins(int rt,int l,int r,int L,int R,int w){
    if(L<=l&&r<=R){
        sum[rt]+=w;
        return ;
    }
    if(L<=mid)ins(ls,l,mid,L,R,w);
    if(mid<R)ins(rs,mid+1,r,L,R,w);
    sum[rt]=sum[ls]+sum[rs];
}
int query(int rt,int l,int r,int L,int R)
{
    if(L<=l&&r<=R)return sum[rt];
    int ans=0;
    if(L<=mid)ans+=query(ls,l,mid,L,R);
    if(mid<R)ans+=query(rs,mid+1,r,L,R);
    return ans;
}
int main()
{
    int t;
    scanf("%d",&t);
    for(int z=1;z<=t;++z){
        printf("Case %d:\n",z);
        scanf("%d",&n);
        build(1,1,n);
        while(1){
            scanf("%s",op);
            if(*op=='E')break;
            if(*op=='Q'){scanf("%d%d",&a,&b);printf("%d\n",query(1,1,n,a,b));}
            else if(*op=='A'){scanf("%d%d",&a,&b);ins(1,1,n,a,a,b);}
            else if(*op=='S'){scanf("%d%d",&a,&b);ins(1,1,n,a,a,-b);}
        }
    }
    return 0;
}

1001

#include<stdio.h>
#include<iostream>
using namespace std;
#define ls (rt<<1)
#define rs (rt<<1|1)
#define mid ((l+r)>>1)
#define maxn 222222
int ma[maxn<<2];
void build(int rt,int l,int r){
    ma[rt]=0;
    if(l==r){
        scanf("%d",&ma[rt]);
        return ;
    }
    build(ls,l,mid);
    build(rs,mid+1,r);
    ma[rt]=max(ma[ls],ma[rs]);
}
void ins(int rt,int l,int r,int L,int  R,int w){
    if(L<=l&&r<=R){
        ma[rt]=w;
        return ;
    }
    if(L<=mid)ins(ls,l,mid,L,R,w);
    if(mid<R)ins(rs,mid+1,r,L,R,w);
    ma[rt]=max(ma[ls],ma[rs]);
}
int query(int rt,int l,int r,int L,int R){
    if(L<=l&&r<=R){
        return ma[rt];
    }
    int ans=0;
    if(L<=mid)ans=max(ans,query(ls,l,mid,L,R));
    if(mid<R)ans=max(ans,query(rs,mid+1,r,L,R));
    return ans;
}
int main()
{
    int n,m,a,b;
    char op[5];
    while(~scanf("%d%d",&n,&m)){
        build(1,1,n);
        while(m--){
            scanf("%s%d%d",op,&a,&b);
            if(*op=='Q')printf("%d\n",query(1,1,n,a,b));
            else if(*op=='U')ins(1,1,n,a,a,b);
        }
    }
    return 0;
}

1002

#include<stdio.h>
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
#define ls (rt<<1)
#define rs (rt<<1|1)
#define mid ((l+r)>>1)
#define maxn 111111
int sum[maxn<<2],lazy[maxn<<2];
void down(int rt,int l,int r){
    if(lazy[rt]){
        lazy[ls]=lazy[rt];
        lazy[rs]=lazy[rt];
        sum[ls]=lazy[rt]*(mid-l+1);
        sum[rs]=lazy[rt]*(r-mid);
        lazy[rt]=0;
    }
}
void build(int rt,int l,int r){
    sum[rt]=0;
    lazy[rt]=0;
    if(l==r){sum[rt]=1;return ;}
    build(ls,l,mid);
    build(rs,mid+1,r);
    sum[rt]=sum[ls]+sum[rs];
}
void ins(int rt,int l,int r,int L,int R,int w){
    if(L<=l&&r<=R){
        sum[rt]=(r-l+1)*w;
        lazy[rt]=w;
        return ;
    }
    down(rt,l,r);
    if(L<=mid)ins(ls,l,mid,L,R,w);
    if(mid<R)ins(rs,mid+1,r,L,R,w);
    sum[rt]=sum[ls]+sum[rs];
}
int main(){
    int t,n,m;
    scanf("%d",&t);
    for(int z=1;z<=t;++z){
        scanf("%d%d",&n,&m);
        build(1,1,n);
        int a,b,c;
        while(m--){
            scanf("%d%d%d",&a,&b,&c);
            ins(1,1,n,a,b,c);
        }
        printf("Case %d: The total value of the hook is %d.\n",z,sum[1]);
    }
    return 0;
}

1003

#include<stdio.h>
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
#define ls (rt<<1)
#define rs (rt<<1|1)
#define mid ((l+r)>>1)
#define maxn 111111
int sum[maxn<<2],lazy[maxn<<2];
void down(int rt,int l,int r){
    if(lazy[rt]){
        lazy[ls]=lazy[rt];
        lazy[rs]=lazy[rt];
        sum[ls]=lazy[rt]*(mid-l+1);
        sum[rs]=lazy[rt]*(r-mid);
        lazy[rt]=0;
    }
}
void build(int rt,int l,int r){
    sum[rt]=0;
    lazy[rt]=0;
    if(l==r){sum[rt]=1;return ;}
    build(ls,l,mid);
    build(rs,mid+1,r);
    sum[rt]=sum[ls]+sum[rs];
}
void ins(int rt,int l,int r,int L,int R,int w){
    if(L<=l&&r<=R){
        sum[rt]=(r-l+1)*w;
        lazy[rt]=w;
        return ;
    }
    down(rt,l,r);
    if(L<=mid)ins(ls,l,mid,L,R,w);
    if(mid<R)ins(rs,mid+1,r,L,R,w);
    sum[rt]=sum[ls]+sum[rs];
}
int main(){
    int t,n,m;
    scanf("%d",&t);
    for(int z=1;z<=t;++z){
        scanf("%d%d",&n,&m);
        build(1,1,n);
        int a,b,c;
        while(m--){
            scanf("%d%d%d",&a,&b,&c);
            ins(1,1,n,a,b,c);
        }
        printf("Case %d: The total value of the hook is %d.\n",z,sum[1]);
    }
    return 0;
}

1004

#include<stdio.h>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string.h>
using namespace std;
#define ls (rt<<1)
#define rs (rt<<1|1)
#define mid ((l+r)>>1)
#define maxn 100001
#define ll long long
ll col[maxn<<2];
int lazy[maxn<<2];
void down(int rt,int l,int r){
    if(lazy[rt]){
        lazy[ls]=lazy[rs]=lazy[rt];
        lazy[rt]=0;
        col[ls]=col[rs]=col[rt];
    }
//    printf("down:l:%d r:%d col[rt]:%lld\n",l,r,col[rt]);
}
void up(int rt,int l,int r){col[rt]=col[ls]|col[rs];
//    printf("up l:%d r:%d col[rt]:%lld\n",l,r,col[rt]);
}
void build(int rt,int l,int r){
    col[rt]=0;
    lazy[rt]=0;
    if(l==r){
        col[rt]=(1<<1);
        return ;
    }
    build(ls,l,mid);
    build(rs,mid+1,r);
    up(rt,l,r);
}
void ins(int rt,int l,int r,int L,int R,int c){
//    printf("iiiiii:%d %d %lld\n",l,r,col[rt]);
    if(L<=l&&r<=R){
        lazy[rt]=1;
              col[rt]=(1<<c);
//        printf("ins:%d %d %lld\n",l,r,col[rt]);
        return ;
    }
    down(rt,l,r);
    if(L<=mid)ins(ls,l,mid,L,R,c);
    if(mid<R)ins(rs,mid+1,r,L,R,c);
    up(rt,l,r);
}
ll query(int rt,int l,int r,int L,int R){
    if(L<=l&&r<=R){
        
//        printf("query:%d %d %lld",l,r,col[rt]);
        return col[rt];
    }
    down(rt,l,r);
    ll ans=0;
    if(L<=mid)ans|=query(ls,l,mid,L,R);
    if(mid<R)ans|=query(rs,mid+1,r,L,R);
    return ans;
}
int main()
{
    int n,x,m,a,b,c;
    char op[5];
    while(~scanf("%d%d%d",&n,&m,&x)){
        build(1,1,n);
        
        while(x--)
        {
            scanf("%s%d%d",op,&a,&b);if(a>b)swap(a,b);
          if(*op=='C'){
            scanf("%d",&c);
            ins(1,1,n,a,b,c);
          }
          else if(*op=='P'){
              ll ans=query(1,1,n,a,b);
              int en=0;
              while(ans){if(ans&1){en++;}ans>>=1;}
            printf("%d\n",en);
          }
        }
        
    }
    return 0;
}

1005 两种姿势：

#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
#define ls (rt<<1)
#define rs (rt<<1|1)
#define mid ((l+r)>>1)
#define maxn 111111
int lm[maxn<<2],rm[maxn<<2],mm[maxn<<2],s[maxn];
void up(int rt,int l,int r){
    lm[rt]=lm[ls];
      rm[rt]=rm[rs];
        mm[rt]=max(mm[ls],mm[rs]);
    if(s[mid]<s[mid+1]){
       mm[rt]=max(mm[rt],rm[ls]+lm[rs]);
       if(lm[ls]==(mid-l+1))lm[rt]+=lm[rs];
         if(rm[rs]==(r-mid))rm[rt]+=rm[ls];
    }
}
void build(int rt,int l,int r){
    if(l==r){
        scanf("%d",&s[l]);
         lm[rt]=rm[rt]=mm[rt]=1;
        return ;
    }
    build(ls,l,mid);
     build(rs,mid+1,r);
      up(rt,l,r);
}
void ins(int rt,int l,int r,int L,int R,int w){
    if(L<=l&&r<=R){
        s[l]=w;
         mm[rt]=lm[rt]=rm[rt]=1;
          return ;
    }
    if(L<=mid)ins(ls,l,mid,L,R,w);
    if(mid<R)ins(rs,mid+1,r,L,R,w);
    up(rt,l,r);
}
int query(int rt,int l,int r,int L,int R){
    if(L<=l&&r<=R){
        return mm[rt];
    }
    if(R<=mid)return query(ls,l,mid,L,R);
    if(L>mid)return query(rs,mid+1,r,L,R);
    else {
        int tmp=0,ltmp,rtmp;
          ltmp=query(ls,l,mid,L,mid);
             rtmp=query(rs,mid+1,r,mid+1,R);
                tmp=max(ltmp,rtmp);
        if(s[mid]<s[mid+1]){
            tmp=max(tmp,min(rm[ls],mid-L+1)+min(lm[rs],R-mid));
        }
        return tmp;
    }
}
int main()
{
    int t,n,m,a,b;
    char op[5];
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&m);
        build(1,1,n);
        while(m--){
            scanf("%s%d%d",op,&a,&b);
            if(*op=='Q')printf("%d\n",query(1,1,n,a+1,b+1));
            else if(*op=='U'){
                ins(1,1,n,a+1,a+1,b);
            }
        }
    }
    return 0;
}

姿势2:

#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
#define ls (rt<<1)
#define rs (rt<<1|1)
#define mid ((l+r)>>1)
#define maxn 111111
int lm[maxn<<2],rm[maxn<<2],mm[maxn<<2],s[maxn];
void up(int rt,int l,int r){
    lm[rt]=lm[ls];
      rm[rt]=rm[rs];
        mm[rt]=max(mm[ls],mm[rs]);
    if(s[mid]<s[mid+1]){
       mm[rt]=max(mm[rt],rm[ls]+lm[rs]);
       if(lm[ls]==(mid-l+1))lm[rt]+=lm[rs];
         if(rm[rs]==(r-mid))rm[rt]+=rm[ls];
    }
}
void build(int rt,int l,int r){
    if(l==r){
        scanf("%d",&s[l]);
         lm[rt]=rm[rt]=mm[rt]=1;
        return ;
    }
    build(ls,l,mid);
     build(rs,mid+1,r);
      up(rt,l,r);
}
void ins(int rt,int l,int r,int L,int R,int w){
    if(L<=l&&r<=R){
        s[l]=w;
         mm[rt]=lm[rt]=rm[rt]=1;
          return ;
    }
    if(L<=mid)ins(ls,l,mid,L,R,w);
    if(mid<R)ins(rs,mid+1,r,L,R,w);
    up(rt,l,r);
}
struct node{
    int l,r,m;
    node(int l=1,int r=1,int m=1):l(l),m(m),r(r){}
};
node query(int rt,int l,int r,int L,int R){
    node tmp,ltmp,rtmp;
    if(L<=l&&r<=R){
        tmp.m=mm[rt];
         tmp.l=lm[rt];
           tmp.r=rm[rt];
        return tmp;
    }
    if(R<=mid)return query(ls,l,mid,L,R);
      else if(L>mid)return query(rs,mid+1,r,L,R);
      else{
            ltmp=query(ls,l,mid,L,mid);
               rtmp=query(rs,mid+1,r,mid+1,R);
          tmp.m=max(ltmp.m,rtmp.m);
            tmp.l=ltmp.l;
              tmp.r=rtmp.r;
      if(s[mid]<s[mid+1]){
            tmp.m=max(tmp.m,ltmp.r+rtmp.l);
              if(ltmp.l==(mid-L+1))tmp.l+=rtmp.l;
                if(rtmp.r==(R-mid))tmp.r+=ltmp.r;
            }
          return tmp;
      }
}
int main()
{
    int t,n,m,a,b;
    char op[5];
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&m);
        build(1,1,n);
//        for(int i=0;i<=(n<<2);++i)lm[i]=rm[i]=mm[i]=0;
//            for(int i=1;i<=n;++i){scanf("%d",&a);ins(1,1,n,i,i,a);}
        while(m--){
            scanf("%s%d%d",op,&a,&b);
            if(*op=='Q')printf("%d\n",query(1,1,n,a+1,b+1).m);
            else if(*op=='U'){
                ins(1,1,n,a+1,a+1,b);
            }
        }
    }
    return 0;
}

1006

#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
#define ls (rt<<1)
#define rs (rt<<1|1)
#define mid ((l+r)>>1)
#define maxn 111111
int lmax[maxn<<2],rmax[maxn<<2],mmax[maxn<<2];
int set[maxn<<2];
void build(int rt,int l,int r){
    set[rt]=-1;
    lmax[rt]=rmax[rt]=mmax[rt]=(r-l+1);
    if(l==r)return ;
    build(ls,l,mid);
    build(rs,mid+1,r);
}
void up(int rt,int l,int r){
    lmax[rt]=lmax[ls];
    rmax[rt]=rmax[rs];
    
    mmax[rt]=max(mmax[ls],mmax[rs]);
      mmax[rt]=max(mmax[rt],rmax[ls]+lmax[rs]);
    
    if(lmax[ls]==(mid-l+1))lmax[rt]+=lmax[rs];
      if(rmax[rs]==(r-mid))rmax[rt]+=rmax[ls];
}
void down(int rt,int l,int r){
    if(set[rt]!=-1){
        set[ls]=set[rs]=set[rt];
        mmax[ls]=lmax[ls]=rmax[ls]=set[rt]?0:(mid-l+1);
        mmax[rs]=lmax[rs]=rmax[rs]=set[rt]?0:(r-mid);
        set[rt]=-1;
    }
}
void ins(int rt,int l,int r,int L,int R,int w){
    if(L<=l&&r<=R){
        set[rt]=w;
        mmax[rt]=lmax[rt]=rmax[rt]=set[rt]?0:(r-l+1);
        return ;
    }
    down(rt,l,r);
    if(L<=mid)ins(ls,l,mid,L,R,w);
    if(mid<R)ins(rs,mid+1,r,L,R,w);
    up(rt,l,r);
}
int query(int rt,int l,int r,int w){
    if(lmax[rt]>=w)return l;
    down(rt,l,r);
    if(mmax[ls]>=w)return query(ls,l,mid,w);
    if((rmax[ls]+lmax[rs])>=w)return mid-rmax[ls]+1;
    return query(rs,mid+1,r,w);
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    
    int op,a,b;
    build(1,1,n);
    
    while(m--)
    {
        scanf("%d",&op);
        if(op==1){
            scanf("%d",&a);
            if(mmax[1]<a)printf("0\n");
            else
            {
                int _x=query(1,1,n,a);
                printf("%d\n",_x);
                ins(1,1,n,_x,_x+a-1,1);
            }
        }
        else{
            scanf("%d%d",&a,&b);
            ins(1,1,n,a,a+b-1,0);
        }
    }
    return 0;
}

1007

#pragma comment(linker,"/STACK:102400000,102400000")
#include<vector>
#include<stdio.h>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string.h>
#include<string.h>
#include<map>
using namespace std;
#define ls (rt<<1)
#define rs (rt<<1|1)
#define mid ((l+r)>>1)
#define maxn 222222
int mx[maxn<<2];
void up(int rt,int l,int r){
    mx[rt]=max(mx[ls],mx[rs]);
}
void build(int rt,int l,int r){
    mx[rt]=-1;
    if(l==r)return ;
    build(ls,l,mid);
    build(rs,mid+1,r);
}
void ins(int rt,int l,int r,int L,int R,int w){
    if(L<=l&&r<=R){
        mx[rt]=w;
        return ;
    }
    if(L<=mid)ins(ls,l,mid,L,R,w);
    if(mid<R)ins(rs,mid+1,r,L,R,w);
    up(rt,l,r);
}
int query(int rt,int l,int r,int L,int R){
    if(L<=l&&r<=R){
        return mx[rt];
    }
    int ans=-1;
    if(L<=mid)ans=max(ans,query(ls,l,mid,L,R));
    if(mid<R)ans=max(ans,query(rs,mid+1,r,L,R));
    return ans;
}
int L[maxn],R[maxn],clc;
vector<int>g[maxn];
void dfs(int u){
    L[u]=++clc;
    for(int i=0;i<g[u].size();++i)
        dfs(g[u][i]);
    R[u]=++clc;
}
int n,m;
int ans[maxn];
void init(){
    for(int i=0;i<=n;++i)g[i].clear();
    memset(ans,-1,sizeof ans);
    clc=-1;
    build(1,1,maxn);
}
struct Man{
    int abi,loy,id;
}man[maxn];
int cmp(Man x,Man y){
    if(x.abi!=y.abi)return x.abi>y.abi;
    return x.id<y.id;
}
int main()
{
    int t,a,b,c;
    scanf("%d",&t);
    while(t--){
        map<int,int>mp;
        scanf("%d%d",&n,&m);
        init();
          n--;
        for(int i=1;i<=n;++i){
            scanf("%d%d%d",&a,&b,&c);
            g[a].push_back(i);
            
            man[i].loy=b;
            man[i].abi=c;
            man[i].id=i;
            mp[b]=i;
        }
        dfs(0);
        sort(man+1,man+n+1,cmp);
        for(int i=1;i<=n;++i){
            int loy=query(1,1,maxn,L[man[i].id],R[man[i].id]);
            
            if(loy<0)ans[man[i].id]=-1;
            else ans[man[i].id]=mp[loy];
            
            ins(1,1,maxn,L[man[i].id],L[man[i].id],man[i].loy);
        }
        for(int i=0;i<m;++i){
            scanf("%d",&c);
            printf("%d\n",ans[c]);
        }
    }
    return 0;
}