线段树基本操作(单点更新，区间更新，区间最大最小值，区间和）poj3468&poj3264&hdu1698&&hdu1166&hdu1754

最新推荐文章于 2024-09-06 18:17:11 发布

原创最新推荐文章于 2024-09-06 18:17:11 发布 · 335 阅读

1 ·

CC 4.0 BY-SA版权

线段树专栏收录该内容

4 篇文章

订阅专栏

本文通过讲解poj3468、hdu1698、hdu1166、hdu1754和poj3264等题目，详细阐述了线段树的基本操作，包括区间求和、区间更新、区间最大最小值的查找以及单点更新。同时，对比了区间最大值查询与求和的区别，以及单点更新的不同处理方式。

poj3468线段树区间求和 +区间更新（模板）

#include <iostream>
#include <algorithm>
#include <string.h>
#include <stdio.h>
#define L o<<1//*2
#define R o<<1|1//*2+1
#define ll long long

using namespace std;
struct node
{
    int l,r;//区间
    long long sum;//区间和
    long long lazy;//延迟值
    int length;//区间长度

}Tree[100000*4];//一般取需求值的4倍
void pushon(int o)
{
    Tree[o].sum=Tree[L].sum+Tree[R].sum;//归并最大值
}
void build(int o ,int l ,int r)
{
    Tree[o].l=l;
    Tree[o].r=r;
    Tree[o].lazy=0;
    Tree[o].length=r-l+1;
    if(l==r)
    {
        scanf("%lld",&Tree[o].sum);
        return;//直接返回
    }
    int mid=(l+r)/2;//只有创建树的时候是（l+r）/2
    build(L,l,mid);//和归并类似，不过函数前多一个L，R
    build(R,mid+1,r);
    pushon(o);//归并区间的总和
}
void pushdown(int o)//更新区间值
{
    if(Tree[o].lazy)
    {
        Tree[L].sum=Tree[L].sum+Tree[L].length*Tree[o].lazy;//原来的+区间长度*增加的值
        Tree[R].sum=Tree[R].sum+Tree[R].length*Tree[o].lazy;
        Tree[L].lazy+=Tree[o].lazy;
        Tree[R].lazy+=Tree[o].lazy;
        Tree[o].lazy=0;
    }
}
void update(int o,int l ,int r,int lazy)
{
    if(Tree[o].l==l&&Tree[o].r==r)
    {
        Tree[o].sum+=lazy*Tree[o].length;//这里是函数的lazy
        Tree[o].lazy+=lazy;
        return;
    }
    pushdown(o);//更新区间延迟值
    int mid=(Tree[o].l+Tree[o].r)/2;//这里是Tree[o].l .r注意！
    if(mid>=r)
    {
        update(L,l,r,lazy);
    }
    else if(l>mid)
    {
        update(R,l,r,lazy);
    }
    else
    {
        update(L,l,mid,lazy);
        update(R,mid+1,r,lazy);
    }
    pushon(o);//更新总体区间sum值
}
long long Query(int o,int l,int r)
{
    if(Tree[o].l==l&&Tree[o].r==r)
    {
        return Tree[o].sum;//恰好等于区间长度
    }
    pushdown(o);//更新延迟值，防止之前没更新
    int mid=(Tree[o].l+Tree[o].r)/2;//这里是Tree[o].l .r注意！
    if(mid>=r)//相当与最小值比 最右边区间r还大
    {
        return  Query(L,l,r);//l-r
    }
    else if(l>mid) //相当与最大值比 最左边区间l还小
    {
        return Query(R,l,r);//l-r
    }
    else
    {
        return (Query(L,l,mid)+Query(R,mid+1,r));
    }
}
int main()
{
    int n,m,x,y,z;
    scanf("%d%d",&n,&m);
    build(1,1,n);
    char op[3];
    while(m--)
    {
        scanf("%s",op);
        if(op[0]=='C')
        {
            scanf("%d%d%d",&x,&y,&z);
            update(1,x,y,z);
        }
        else
        {
            scanf("%d%d",&x,&y);
            printf("%lld\n",Query(1,x,y));
        }
    }

}

这道题比较经典，其实感觉上就是一个归并的一个过程，从下到上归并，因此可以得到区间和

这道题可以用于解决区间和的模板，而且代码也感觉上是比较舒服的，题目需要加深理解

hdu1698和上题类似，唯一不同的是，区间更新成为一个定值

而且这题直接输出T[1].sum就可以了，不需要询问区间

#include <iostream>
#include <cstdio>
#define L o<<1
#define R o<<1|1

using namespace std;
struct node
{
    int l,r;
    int sum;
    int length;
    int lazy;
} T[400000];
void pushup(int o)
{
    T[o].sum=T[L].sum+T[R].sum;
}
void pushdown(int o)
{
    if(T[o].lazy)
    {
        T[L].sum=T[L].length*T[o].lazy;//与上题不同的地方，不是叠加而是直接赋值
        T[R].sum=T[R].length*T[o].lazy;
        T[L].lazy=T[o].lazy;
        T[R].lazy=T[o].lazy;
        T[o].lazy=0;
    }
}
void build(int o,int l,int r)
{
    T[o].l=l;
    T[o].r=r;
    T[o].lazy=0;
    T[o].length=r-l+1;
    if(l==r)
    {
        T[o].sum=1;
        return ;
    }
    int mid=(l+r)/2;
    build(L,l,mid);
    build(R,mid+1,r);
    pushup(o);
}
void update(int o,int l,int r,int lazy)
{
    if(T[o].l==l&&T[o].r==r)
    {
        T[o].sum=lazy*T[o].length;
        T[o].lazy=lazy;
        return ;
    }
    pushdown(o);
    int mid=(T[o].l+T[o].r)/2;
    if(r<=mid) update(L,l,r,lazy);
    else if(l>mid) update(R,l,r,lazy);
    else
    {
        update(L,l,mid,lazy);
        update(R,mid+1,r,lazy);
    }
    pushup(o);
}
int main()
{
    int n,i,m,a,b,pos,t;
    scanf("%d",&t);
    for(int j=1;j<=t;j++)
    {

        scanf("%d%d",&n,&m);
        build(1,1,n);
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&pos);
            update(1,a,b,pos);
            //printf("%d\n",T[1].sum);
        }
      printf("Case %d: The total value of the hook is %d.\n",j,T[1].sum);
    }
}

hdu1166区间求和，单点更新，我们同样可以用上题模板，区间[a,b]，那么假如a==b,[a,b]就相当于[a,a]即单点，其余相同

#include <iostream>
#include <algorithm>
#include <string.h>
#include <stdio.h>
#define L o<<1//*2
#define R o<<1|1//*2+1
#define ll long long

using namespace std;
struct node
{
    int l,r;//区间
    long long sum;//区间和
    long long lazy;//延迟值
  //  int length;//区间长度

}Tree[100000*4];//一般取需求值的4倍
void pushon(int o)
{
    Tree[o].sum=Tree[L].sum+Tree[R].sum;//归并最大值
}
void build(int o ,int l ,int r)
{
    Tree[o].l=l;
    Tree[o].r=r;
    Tree[o].lazy=0;
    //Tree[o].length=r-l+1;
    if(l==r)
    {
        scanf("%lld",&Tree[o].sum);
        return;//直接返回
    }
    int mid=(l+r)/2;//只有创建树的时候是（l+r）/2
    build(L,l,mid);//和归并类似，不过函数前多一个L，R
    build(R,mid+1,r);
    pushon(o);//归并区间的总和
}
void pushdown(int o)//更新区间值
{
    if(Tree[o].lazy!=0)
    {
        Tree[L].sum+=Tree[o].lazy;//原来的+区间长度*增加的值
        Tree[R].sum+=Tree[o].lazy;
        Tree[L].lazy+=Tree[o].lazy;
        Tree[R].lazy+=Tree[o].lazy;
        Tree[o].lazy=0;
    }
}
void update(int o,int l ,int r,int lazy)
{
    if(Tree[o].l==l&&Tree[o].r==r)
    {
        Tree[o].sum+=lazy;//这里是函数的lazy
        Tree[o].lazy+=lazy;
        return;
    }
    pushdown(o);//更新区间延迟值
    int mid=(Tree[o].l+Tree[o].r)/2;//这里是Tree[o].l .r注意！
    if(mid>=r)
    {
        update(L,l,r,lazy);//并不需要用到mid
    }
    else if(l>mid)
    {
        update(R,l,r,lazy);
    }
    else
    {
        update(L,l,mid,lazy);
        update(R,mid+1,r,lazy);
    }
    pushon(o);//更新总体区间sum值
}
long long Query(int o,int l,int r)
{
    if(Tree[o].l==l&&Tree[o].r==r)
    {
        return Tree[o].sum;//恰好等于区间长度
    }
    pushdown(o);//更新延迟值，防止之前没更新
    int mid=(Tree[o].l+Tree[o].r)/2;//这里是Tree[o].l .r注意！
    if(mid>=r)//相当与最小值比 最右边区间r还大
    {
        return  Query(L,l,r);//l-r
    }
    else if(l>mid) //相当与最大值比 最左边区间l还小
    {
        return Query(R,l,r);//l-r
    }
    else
    {
        return (Query(L,l,mid)+Query(R,mid+1,r));
    }
}
int main()
{
    int n,m,x,y,z,t;
   scanf("%d",&t);
   m=t;
   while(t--)
   {
    printf("Case %d:\n",m-t);
    scanf("%d",&n);
    build(1,1,n);
    char op[6];
    while(1)
    {
        scanf("%s",op);
        if(op[0]=='E') break;
        if(op[0]=='A')
        {
            scanf("%d%d",&x,&z);
            update(1,x,x,z);
        }
        if(op[0]=='S')
        {
            scanf("%d%d",&x,&z);
            update(1,x,x,-z);
        }
        else if(op[0]=='Q')
        {
            scanf("%d%d",&x,&y);
            printf("%lld\n",Query(1,x,y));
        }
    }
   }

}

hdu1754求区间最大值，单点更新

那么这道题需要放弃上面的一些思路，例如结构体来规定节点的区间，区间长度，pushup函数中，应改为归并求最大值即max(T[L],T[R)

（询问的区别）应判断a<=mid<b,取在递归过程的max

当询问的区间【a,b】包含【l,r】的时候，也就是说，你所寻找的最大值一定在【l，r】的时候，直接返回T【o】

并且，除了build函数以外，区间求和的mid=(T[o].l+T[o].r)/2，而在找最大值中mid=(l+r)/2，一定要注意区别

（单点更新的区别）这一个是完整意义上的单点更新，之前是利用区间趋向于那个点来更新点，一定要判断更新的那个点pos值<=r成不成立，而且递归区间应是(L,l,mid) and (R,mid+1,r)这个在代码中会有所体现

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <string.h>
#include <math.h>
#define L o*2
#define R o*2+1

using namespace std;
int M[4000009];
void pushup(int o)
{
    M[o]=max(M[L],M[R]); //这里和区间求和有所不同，应做一个max[]数组去存储最大值
}
void build(int o,int l,int r)
{
    if(l==r)
    {
        scanf("%lld",&M[o]);//当区间变成一个点时输入
        return ;
    }
    int mid=(l+r)/2;
    build(L,l,mid);
    build(R,mid+1,r);//相当于归并
    pushup(o);

}
void update(int o,int l,int r,int pos,int lazy)//与求区间和类似
//lazy值是直接改变，pos值是那个点的坐标
{
    if(l==r&&l==pos)
    {
        M[o]=lazy;//找到pos这一个点
        return;//结束
    }
    int mid=(l+r)/2;
    if(pos<=mid) update(L,l,mid,pos,lazy);//在左边
    else update(R,mid+1,r,pos,lazy);//与更新区间有所不同
    //是直接mid与那个点做比较
    pushup(o);
}
int query(int o,int l,int r,int a,int b )//a-b为要找区间
{
    if(a<=l&&r<=b)//如果l-r区间在这a-b里面，那么就相当于m[o]一定是[l,r]的最大值
    {
        return M[o];
    }
    int mid=(l+r)/2;
    int temp=0;
    if(a<=mid)
    {
        temp=max(temp,query(L,l,mid,a,b));//左边那一部分最大值，不断递归找出所有的最大值
    }
    if(b>mid)

    {
        temp=max(temp,query(R,mid+1,r,a,b));//右边那一部分最大值
    }
    return temp;
}
int main()
{
    int n,m,a,b,i;
    char c[2];
    while(~scanf("%d%d",&n,&m))
    {
        build(1,1,n);
        for(i=1; i<=m; i++)
        {
            scanf("%s",c);
            if(c[0]=='Q')
            {
                scanf("%d%d",&a,&b);
                printf("%d\n",query(1,1,n,a,b));

            }
            else
            {
                scanf("%d%d",&a,&b);
                update(1,1,n,a,b);
            }
        }
    }
}

poj3264线段树区间max-min,这题没有更新，思路和上面的求区间max一样，但是应该利用全局变量取带回max,min的值或者直接把上一题的求max的值的函数改成两个，一个求max，一个求min也是可以的，这也是两个思路去做

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string.h>
#define L o<<1
#define R o<<1|1

using namespace std;
int Min[200009];
int Max[200009];
int ant1;
int ant2;
void pushup(int o)
{
    Min[o]=min(Min[L],Min[R]);
    Max[o]=max(Max[L],Max[R]);
}
void build(int o,int l,int r)
{
    if(l==r)
    {
        scanf("%d",&Min[o]);
        Max[o]=Min[o];
        return ;//结束！！！！
    }
    int mid=(l+r)/2;
    build(L,l,mid);
    build(R,mid+1,r);
    pushup(o);
}
void query(int o,int l,int r,int a,int b)
{
    if(a<=l&&r<=b)
    {
        ant1=max(ant1,Max[o]);
        ant2=min(ant2,Min[o]);
        return;//利用全局变量取min,max
    }
    int mid=(l+r)/2;//询问求范围
    if(a<=mid)
    {
        query(L,l,mid,a,b);
    }
    if(b>mid)
    {
        query(R,mid+1,r,a,b);
    }
}

int main()
{
    int n,m,i,a,b;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        build(1,1,n);
        for(i=1;i<=m;i++)
        {
            scanf("%d%d",&a,&b);
            ant1=0;//max
            ant2=1000001;//min
            query(1,1,n,a,b);
            //printf("%d %d\n",ant1,ant2);
            printf("%d\n",ant1-ant2);
        }
    }
}