数据结构颓废计划III-基础线段树

最新推荐文章于 2024-09-10 20:37:54 发布

Robin__Lu

最新推荐文章于 2024-09-10 20:37:54 发布

阅读量298

点赞数

分类专栏： CodeVS 文章标签：数据结构线段树

本文链接：https://blog.csdn.net/Robin__Lu/article/details/54798902

版权

CodeVS 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

定义与表示方法

线段树是一种二叉树，树中的每一个结点表示了一个区间。
每一个叶子节点表示了一个单位区间。考虑叶子节点，有两种可能：

1 表示为 $[A,A+1]$ 形式

第1种表示
容易看出，这个线段树是连续的，即在 $[1,10]$ 这个区间中没有任何的断点。这种形式适合表示一根完整的数轴。

2 表示为 $[A,A+1)$ 形式

第2种表示

本图出自上古神犇刘汝佳的ppt。Orz

容易看出这种线段树适合维护一个序列，即每个元素都是分立的。

题外话：二叉树的表示方法

对于二叉树，有两种表示方法，一种是用深度优先的先序存储每个节点，然后存储父子关系，另一种是使用完全二叉树的结论，那么以层次标号，即i节点的左子节点为 $i*2$ ，右子节点为 $i*2+1$ 。

用途与限制

线段树的用途较为多样化。一般的说，在序列上，它可以维护：
1、单点修改，区间求值
2、区间修改，单点求值
3、区间修改，区间求值
在数轴上同理。接下来我们分析它们的原理。

单点修改，区间求值

最简单的线段树

其实不需要太多解释，修改时自底至顶，查询时自顶至底。

例题:序列操作1(squen1.pas/c/cpp)

问题描述

给定一个有n个数的a数组a[1],a[2],…,a[n]。有m个操作，操作分为
两种：
1)给出两个整数l,r，问a[l],…,a[r]这r-l+1个数中的最大数是多少。
2)给出两个整数x,k，把a[x]改为k。

输入

第一行两个整数n,m，第二行起n个整数表示初始时的a数组；
接下来有m行，每行3个整数d,b,c，如果d=1，那么输出a[b]~a[c]中
最大的数；如果d=2，那么将a[b]改为c。

输出

每行一个整数，对应每一个d=1的操作。

样例输入

样例输出

4
5

来源

市科艺中心练习题

解答

这题是一道裸题，但是有一个奇怪的问题，即按照完全二叉树序存储节点莫名会被卡常数，而且似乎常数不是一般的大。用深度序是可以过这道题的。

代码(被卡常版)

#include <cstring>
#include <cstdio>
#include <cstdlib>
using namespace std;
int segment_tree[400001];
int N,M;
int x;
int max( int a , int b )
 {
    return a>b?a:b;
 }
void update( int i , int l , int r , int a , int x ) 
 {
      if(r==l)
       {
           segment_tree[i]=x;
           return ;
       }
      int mid=(l+r)>>1;
      if(a>=l&&a<=mid)
          update(i<<1,l,mid,a,x);
      else if(a<=r&&a>=mid+1)
          update((i<<1)+1,mid+1,r,a,x);
      segment_tree[i]=max(segment_tree[i<<1],segment_tree[(i<<1)+1]);
      return ;
    }
int query( int i , int l , int r , int a , int b )
 {
       int mid=(l+r)>>1;
       if(l==r&&a==b)
          return segment_tree[i];
       else if(a>=l&&b<=mid)
          return query(i<<1,l,mid,a,b);
       else if(a>=mid+1&&b<=r)
          return query((i<<1)+1,mid+1,r,a,b);
       else 
          return max(query(i<<1,l,mid,a,mid),query((i<<1)+1,mid+1,r,mid+1,b));
 }
inline char read(int &n){
    int x = 0, tmp = 1; char c = getchar();
    while((c < '0' | c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return c;
}

int main()
 {
          memset(segment_tree,0,sizeof(segment_tree));
      read(N);
      read(M);
      for ( int i=1;i<=N;i++)
         {
            read(x);
            update(1,1,N,i,x);
         }
       int l,r;
       for ( int i=1;i<=M;i++)
         {
             read(x);
             read(l);
             read(r);
             if(x==2)
                   update(1,1,N,l,r);
             else
                   printf("%d\n",query(1,1,N,l,r));
         }
        return 0;
 }

代码(AC版)

#include <iostream>
#include <cstdio> 
#define maxn 1000000+1
using namespace std;
int key[maxn*2],l[maxn*2],r[maxn*2];
int a[maxn];
int d=0,ql=0,qr=0,root=0,tot=0,i=0,j=0,n=0,m=0;
inline char read(int &n){
    int x = 0, tmp = 1; char c = getchar();
    while((c < '0' | c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return c;
}
void update( int x )
 {
     key[x]=max(key[l[x]],key[r[x]]);
 }
int build(int s,int t)
 {
    int now=0,mid=0;
    mid=(s+t)>>1;
    tot++;
    now=tot;
    if(s==t)
      {
          key[now]=a[s];
          return now;
       }
    l[now]=build(s,mid);
    r[now]=build(mid+1,t);
    update(now);
    return now;
 }
int query(int x,int s,int t)
 {
    int ans=0,mid=0;
    if(ql<=s&&t<=qr)
        return key[x];
    mid=(s+t)>>1;
    if(ql<=mid)
      ans=query(l[x],s,mid);
    else
     {
        ans=-10000000;}
        if(qr>mid)  
          ans=max(ans,query(r[x],mid+1,t));
    return ans;
 }
void insert(int x,int s,int t)
 {
    int mid=0;
    if(ql==t&&s==t)
     {
        key[x]=qr;
        return ;
      }
    mid=(s+t)>>1;
    if(ql<=mid)
      insert(l[x],s,mid);
    else
      insert(r[x],mid+1,t);
    update(x);
 }
int main()
 {
     read(n);
     read(m);
     for ( int i=1;i<=n;i++)
       read(a[i]);
     root=build(1,n);
     for ( int i=1;i<=m;i++)
      {
        read(d),read(ql),read(qr);
        if(d==1)
           printf("%d\n",query(root,1,n));
        else 
           insert(root,1,n);
       }
      return 0;
 }

习题：为什么第一个版本的代码会被蜜汁卡常

区间修改

如果一个一个修改区间内的所有点，那么最坏情况下修改一次的代价为 $O(Nlog_2N)$ ，算法迅速退化的比平方阶还难看。
考虑到查询要求并没有那么苛刻(否则明显不可做)，那么必定是包含冗余信息的。由这种想法，我们催生出了延迟标记思想(lazy_tag)。

延迟标记

延迟标记的思想，就是我修改的时候只记录我要修改什么，而不真正的去修改什么，而到下一次操作的时候再把修改信息传递到下一级。实践证明，这是一个很好的思想(捂脸)。可以

区间查询和单点查询

其实已经不是难点了。但是区间查询显然难写。单点查询的话只要一层一层把修改信息下推即可。而区间查询时，我们只下推到我们查询到的地方。

例题

CodeVS1081 线段树练习2 区间修改，单点求值

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
using namespace std;
int N;
int lazy_tag[400001];
int DATA[100001];
void update( int i , int l , int r , int st , int en ,  int x )
  {
        int mid=(l+r)>>1;
        if((st==l)&&(en==r))
            {
               lazy_tag[i]+=x;
               return ;
            }
        if(l==r)
          return ;
        if(lazy_tag[i]!=0)
            {
                lazy_tag[i+i]+=lazy_tag[i];
                lazy_tag[i+i+1]+=lazy_tag[i];
                lazy_tag[i]=0;
             }
        if(en<=mid)
           update( i+i , l , mid , st , en , x );
        else if(st>mid)
           update( i+i+1 , mid+1, r , st , en , x);
        else
           {
             update(i+i,l,mid,st,mid,x);
             update(i+i+1,mid+1,r,mid+1,en,x);
           }
        return ;
  }
int GetAns( int i , int l , int r , int x )
 {
     if(l==r)
        return lazy_tag[i]+DATA[l];
     if(lazy_tag[i]!=0) 
        {
            lazy_tag[i+i]+=lazy_tag[i];
            lazy_tag[i+i+1]+=lazy_tag[i]; 
            lazy_tag[i]=0;
        }
     int mid=(l+r)>>1;
     if(x<=mid)
        return GetAns(i+i,l,mid,x);
     else if(x>mid)
        return GetAns(i+i+1,mid+1,r,x);
 }
int main()
  {
     scanf("%d",&N);
     memset(lazy_tag,0,sizeof(lazy_tag));
     for ( int i=1;i<=N;i++)
        scanf("%d",&DATA[i]);
     int _,__,a,b,x;
     scanf("%d",&_);
     for ( int i=1;i<=_;i++)
      { 
          scanf("%d",&__);
          if(__==1)
            {
                scanf("%d%d%d",&a,&b,&x);
                update(1,1,N,a,b,x);
                }
          if(__==2)
            {
                scanf("%d",&x);
                printf("%d\n",GetAns(1,1,N,x));
            }
        }
    return 0;
  }

CodeVS1082 线段树练习3 区间修改，区间求和

#include<cstdio>
#include<cstring>
#include<cstdlib>
#define ls (i<<1)
#define rs ((i<<1)|1)
#define N 200000
using namespace std;
long long A[N];
long long Segment_Tree[4*N+1];//要开4倍
long long n,m,a,b,c;
int flag;
long long size[4*N+1];
long long liad[4*N+1];
void build(long long i,long long l,long long r){//建树 
    size[i]=r-l+1;
    if(l==r){Segment_Tree[i]=A[l];return;}
    int mid=(l+r)>>1;
    build(ls,l,mid);
    build(rs,mid+1,r);
    Segment_Tree[i]=Segment_Tree[rs]+Segment_Tree[ls];
    return;
}
void write(long long i){Segment_Tree[rs]+=liad[i]*size[rs],Segment_Tree[ls]+=liad[i]*size[ls],liad[rs]+=liad[i],liad[ls]+=liad[i],liad[i]=0;}
void update(long long L,long long R,long long v,long long i,long long l,long long r){
    if(L!=R)write(i);
    if(L>=l&&R<=r){Segment_Tree[i]+=v*size[i];liad[i]+=v;return;}
    int mid=(R+L)>>1;
    if(mid<l)update(mid+1,R,v,rs,l,r);
    else if(mid>=r)update(L,mid,v,ls,l,r);
        else{
            update(L,mid,v,ls,l,r);
            update(mid+1,R,v,rs,l,r);
         }
    Segment_Tree[i]=Segment_Tree[rs]+Segment_Tree[ls];
}
long long query(long long i,long long L,long long R,long long a,long long b){
    if(L!=R)write(i);
    if(a<=L&&b>=R)return Segment_Tree[i];
    int mid=(L+R)>>1;
    if(mid<a)return query(rs,mid+1,R,a,b);
    else if(mid>=b)return query(ls,L,mid,a,b);
    else return query(ls,L,mid,a,b)+query(rs,mid+1,R,a,b);
}
int main(){
    scanf("%lld",&n);
    for(int i=1;i<=n;++i)
    scanf("%lld",&A[i]);
    build(1,1,n);
    scanf("%lld",&m);
    for(int i=1;i<=m;i++){
        scanf("%d",&flag);
        if(flag==1){
            scanf("%lld%lld%lld",&a,&b,&c);
            update(1,n,c,1,a,b);
        }
        else{
            scanf("%lld%lld",&a,&b);

        printf("%lld\n",query(1,1,n,a,b));
        }
    }
    return 0;
}