[模版]线段树

(欢迎咨询QQ3228648095)

线段树

线段树是个啥呀

线段树是个毛???在前面我只能告诉你又长又骚。线段树的代码,板子题都有将近百行,稍微有点思想的题目估计就要上一百五十行了。然后差错的时候哦查到你心累,这就是线段树……

算了还是来点正能量的吧。

线段树有着不可比拟的有点,它是可以快捷地对一段数据进行在线维护、查询的数据结构,查询和维护的时间复杂度都是(log2 n)这就很舒服了。

基本原理

线段树是一种二叉搜索树,它将一个区间放在根结点里面,然后不断把区间进行分割,直到分割成一个单位区间(可以理解为一个单结点区间,或者一个不可分割的区间),然后把所有单位区间都放在叶子结点里面,我们查找的时候就可以通过树枝进行搜,如果遇到一个区间和需要查找的区间是包含关系,那就不用查找了,直接返回这个区间的相应参数,如果交叉关系,就继续分割递归,如果没有关系,那就直接return结束本层递归。

对比

和RMQ的对比
RMQ求区间最大值运用了倍增的思想,在预处理后,可以在常数时间内完成查询,也就是查询的时间复杂度是O(1),而预处理的时间复杂的是O(nlog2 n),看起来是不是比这个线段树要好很多?但是——RMQ算法是局限于离线查询,不支持更改,如果要更改的话,时间复杂度蹭蹭蹭上去,而且代码复杂度也很高,我试过,头都大了。但是线段树是支持更改的在线数据结构。
和数组直接存储的对比
数组直接存储不需要预处理,修改需要O(1)的时间,但是查找单点要O(n),查找区间的话要O(n^2)的时间。太慢了(我曹。

线段树的实现

线段树真是个好玩意儿,我们怎么实现它呢?

存储

线段树在本质上是一棵完全二叉树(想一想,为什么)
线段树的存储有很多种办法,但是最省空间的方法是:采用堆结构。对于每一个结点i,a[i]就来存储这个结点,a[2*i]来存储这个点的左孩子,a[2 *i+1]来存储这个点的右孩子。没有优化的空间复杂度是O(2n),但是数组往往需要开到4n,否则会溢出空间哦。
(待更新)

查找和更新

线段树本来就是一种二叉搜索树,查找和更新的时候就可以从根结点一层一层向下递归就ok了。

一个极好的优化

我们会发现,如果对于一棵线段树,我们每次都进行到底的搜索或修改,我们会浪费很多时间,导致tle很多点。我们会发现对于同一个元素,我们在修改维护的时候会经过一次,而且在询问的时候又会经过一次。这样对于多询问题来说就会重复判断操作。我们这里有一个解决办法——延迟修改。
我们一般称之为lazy标记(很懒,只能留到下次经过的时候再处理),然后做法就很显然了:如果当前遇到的区间被要操作的区间所覆盖,那就直接对这个根结点进行标记,以下的子结点就不用再找了,直接return掉。

各种模板

我们的模板是基于一个很好的板子题进行的:

题目

题目描述
如题,已知一个数列,你需要进行下面两种操作:
1.将某区间每一个数加上x
2.将某区间每一个数乘上x
3.求出某区间每一个数的和

输入输出格式
输入格式:
第一行包含三个整数N、M、P,分别表示该数列数字的个数、操作的总个数和模数。
第二行包含N个用空格分隔的整数,其中第i个数字表示数列第i项的初始值。
接下来M行每行包含3或4个整数,表示一个操作,具体如下:
操作1: 格式:1 x y k 含义:将区间[x,y]内每个数乘上k
操作2: 格式:2 x y k 含义:将区间[x,y]内每个数加上k
操作3: 格式:3 x y 含义:输出区间[x,y]内每个数的和对P取模所得的结果
输出格式:
输出包含若干行整数,即为所有操作3的结果。

一些这道题必备的思路

简单来说,如果要修改一个区间的值,如果这个区间刚好被完全包含了就直接返回,打上标记(要改成多少),那么下次要用子节点的时候将标记下传即可,显然,对于本题要打两个tag,那么sum[o] = sum[o] * mul[o] + add[o],sum为和,mul为乘的数,add为加的数,那么如果我们乘一个数c,sum[o] = sum[o] * mul[o] * c + add[o] * c,将mul[o] * c和add[o] * c看作两个整体,那么可以发现如果乘一个数c的话,add数组要*c,mul数组也要*c,同理,如果加一个数c,那么只需要add数组+c即可,因为在下传标记的时候既有加,又有减(可能为0),所以add和mul数组的计算一定要将这两种情况都计算到.如果在线段树上几个区间操作的性质相同的,先把要求的数用操作需要的量给表示出来,然后对于每一种操作看看需要维护的标记的变化,最后合并一下即可.

声明

在上模板代码之前,我们先用了这个头文件:

#include<bits/stdc++.h>

这两个宏定义:

#define le l,mid,o*2
#define re mid+1,r,o*2+1

n用来存储原数列的个数,m用来存储操作的个数,p用来存储需要mod的数,a数组用来存原数列,add数组用来存加法的lazy标记,mul用来存乘法的lazy标记,sum用来存累加和(或对p取模后的值);x和y代表需要更改的区间的两个端点。

建树

void build(long long l,long long r,long long o)
{
    mul[o]=1;//乘法基数1
    add[o]=0;//加法基数0
    if(l==r)//如果这个区间两端点重合啦,就是锁定单点了,这个区间只有一个元素
    {
        sum[o]=a[l];//这个区间的总和就是元素自身了
        return;
    }
    int mid=(l+r)>>1;//获取中间点
    build(le);//继续造树
    build(re);//十年树木百年树人
    sum[o]=(sum[o*2]+sum[o*2+1])%p;//第o个点的累加和是两个孩子的累加和之和
}

传递lazy标记

void pushdown(int o,int k)
{
    sum[o*2]=(sum[o*2]*mul[o]+add[o]*(k-(k>>1)))%p;//左子树的累加和更新
    sum[o*2+1]=(sum[o*2+1]*mul[o]+add[o]*(k>>1))%p;//右子树的累加和更新
    //更新的顺序:先乘法标记的更新,再加上累加标记的更新。并且累加标记的更新还要注意累加的次数,一个是(k-(k>>1)),另一个是(k>>1)。
    mul[o*2]=mul[o*2]*mul[o]%p
    mul[o*2+1]=mul[o*2+1]*mul[o]%p;
    //乘法标记也要更新的。千万别忘记
    add[o*2]=(add[o*2]*mul[o]+add[o])%p;
    add[o*2+1]=(add[o*2+1]*mul[o]+add[o])%p;
    //加法标记更新的时候要先考虑乘法标记的更新。
    mul[o]=1;
    add[o]=0;
    //标记清空。
}

区间自加

void jia(int l,int r,int o)//三个参数,l和r代表当前在查找的区间的两个端点,o代表当前查找的区间的根结点
{
    if(x<=l&&r<=y)//如果区间完全被覆盖
    {
        add[o]=(add[o]+v)%p;//对lazy标记直接累加v,并且模p(一步一模可以避免最后long long溢出的问题)
        sum[o]=(sum[o]+v*(r-l+1))%p;//对于该点的累加和也要相应加上每一个单点的改变量
        return;//lazy标记的初衷,直接退出
    }
    pushdown(o,r-l+1);//传递lazy标记
    int mid=(l+r)>>1;//获取区间中点
    if(x<=mid)
    jia(le);//如果x在中点左边,就说明有必要搜索左子树
    if(y>mid)
    jia(re);//如果y在中点右边,就说明有必要搜索右子树
    sum[o]=(sum[o*2]+sum[o*2+1])%p;
//是时候更新根结点的累加和了。

区间乘法

void cheng(int l,int r,int o)
{
    if(x<=l&&r<=y)
    //如果区间完全包含
    {
        add[o]=(add[o]*v)%p;
        mul[o]=(mul[o]*v)%p;
        sum[o]=(sum[o]*v)%p;
            //累加和、乘法标记、加法标记全部更新。
        return;//更新完就直接返回,不用多说话。
    }
    pushdown(o,r-l+1);//传递标记
    int mid=(l+r)>>1;
    if(x<=mid)
    cheng(le);
    if(y>mid)
    cheng(re);
    sum[o]=(sum[o*2]+sum[o*2+1])%p;
    //这一段同上文加法。
}

区间查找

long long query(int l,int r,int o)
{
    if(x<=l&&r<=y)
    return sum[o]%p;
    //如果完全包含,直接返回值(lazy标记已经被pushdown了)
    int mid=(l+r)>>1;//取中点
    pushdown(o,r-l+1);//传递标记
    long long temp=0;
    if(x<=mid)
    temp=(temp+query(le))%p;
    //左子树的累加和
    if(y>mid)
    temp=(temp+query(re))%p;
    //右子树的累加和
    sum[o]=(sum[o*2]+sum[o*2+1])%p;
    //更新根结点
    return temp%p;
    //返回最后值
}

主函数的一些边缘操作

int main()
{
    n=read();
    m=read();
    p=read();
    //快读(见下)
    for(int i=1;i<=n;i++)
    a[i]=read();
    //读入数据
    build(1,n,1);
    //构造树
    for(int i=1;i<=m;i++)
    {
        pattern=read();
        //读入操作类型
        if(pattern==1)
        {
            x=read();
            y=read();
            v=read();
            cheng(1,n,1);
        }//1就是乘法
        if(pattern==2)
        {
            x=read();
            y=read();
            v=read();
            jia(1,n,1);
        }//2就是加法
        if(pattern==3)
        {
            x=read();
            y=read();
            printf("%lld\n",query(1,n,1)%p);
        }//3就是查找区间累加和并取模
    }
    return 0;
}

快读

这是个好技能。希望大家get到

inline long long read()
{
    long long num=0;
    char c=getchar();
    for(;c<'0'||c>'9';c=getchar());
    for(;c>='0'&&c<='9';c=getchar())num=num*10+c-'0';
    return num;
}
发布了168 篇原创文章 · 获赞 118 · 访问量 8万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览