基础线段树

最新推荐文章于 2024-04-08 20:24:14 发布
最新推荐文章于 2024-04-08 20:24:14 发布
阅读量216 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AuroraVeil/article/details/80709283
版权




一、线段树概念

         线段树是一种完全二叉树，它在每个节点保存数组中一段子数组的信息，从而进行高效的连续区间动态查询问题。

二、基本操作

1.构造(初始化)

         线段树初始化的主要思想是递归如果一个节点(n)保存的线段长度是1则赋值，否则递归构造左(2*n)右(2*n+1)子节点，最后回溯时给该节点赋值。

2.区间查询

         区间查询先把欲查询的区间划分为线段树上的节点，再把这些节点储存的信息整合起来得到需要的信息。

         比如这一简单的线段树，如果查询区间是1-4、1-2等，那可以直接找到相应节点保存的信息来得到结果。如果查询区间是2-4，就不能直接得到结果，需要整合2-2、3-4两个节点的信息得到结果13。

         由此可见，线段树的查询过程选出了最少的节点数来保证这些节点所表示的区间连起来正好是欲查询的区间。考虑到线段树上每层节点最多被选出两个，因此查询时间复杂度是O(log n)。

3.单节点更新

         单节点更新没什么好说的，递归找到要更新的节点，更新节点值，回溯更新父节点直到根节点。

4.区间更新(重点)

         区间更新一个重要思想就是，按照查询的过程将待更新区间划分为多个节点，然后更新这些节点的信息，在此次更新操作中不继续更新这些节点的子节点信息，而是在这些节点添加标记。每当修改和查询到一个节点并且需要继续访问它的子节点时，看看它有没有标记，如果有标记，就按照标记更新其左右子节点信息并为左右子节点添加相同的标记，同时删除该节点的标记。这种区间更新方法不需要暴力更新每个节点的值，大大提高效率。

三、样例代码(区间最小值)



#include<iostream>
#include<string>

using namespace std;

struct segtree
{
private:
    struct node
    {
        node()
        {
            change=0;
        }
        long long int value;
        long long int change;
        int begin;
        int end;
    };
    node *tree;
    int members;
    long long int *buildp;
    void build(int n,int begin,int end)//初始化
    {
        int mid=(begin+end)/2;
        tree[n].begin=begin;
        tree[n].end=end;
        if(begin==end)//搜索到叶子节点，赋值，回溯
        {
            tree[n].value=*buildp;
            ++buildp;
            return;
        }
        build(2*n,begin,mid);
        build(2*n+1,mid+1,end);//递归构造左右子节点
        update(n);
    }
    long long int query(int n,int begin,int end)//区间查询
    {
        long long int q1=-1,q2=-1;
        int mid=(begin+end)/2;
        if(tree[n].begin>end||tree[n].end<begin)//查询区间与当前区间无交集
        {
            return -1;
        }
        if(tree[n].begin>=begin&&tree[n].end<=end)//当前区间为查询区间的子集
        {
            return tree[n].value;
        }
        if(tree[n].change!=0)//检查是否有标记需要处理
        {
            sink(n);
        }
        q1=query(2*n,begin,end);
        q2=query(2*n+1,begin,end);
        if(q1==-1)
        {
            return q2;
        }
        if(q2==-1)
        {
            return q1;
        }
        return min(q1,q2);
    }
    void change(int target,long long int dv,int n)//单点更新
    {
        if(tree[n].begin==tree[n].end)
        {
            tree[n].value+=dv;
            return;
        }
        if(tree[n].change!=0)
        {
            sink(n);
        }
        int mid=(tree[n].begin+tree[n].end)/2;
        if(target<=mid)
        {
            change(target,dv,2*n);
        }
        else
        {
            change(target,dv,2*n+1);
        }
        update(n);
    }
    void areachange(int begin,int end,long long int dv,int n)//区域更新
    {
        if(tree[n].begin>end||tree[n].end<begin)
        {
            return;
        }
        if(tree[n].begin>=begin&&tree[n].end<=end)//当前区间是待更新区间子集，添加标记
        {
            tree[n].change+=dv;
            tree[n].value+=tree[n].change;
            return;
        }
        if(tree[n].change!=0)
        {
            sink(n);
        }
        areachange(begin,end,dv,2*n);
        areachange(begin,end,dv,2*n+1);
        update(n);
    }
    void update(int n)//更新父节点值
    {
        tree[n].value=min(tree[2*n].value,tree[2*n+1].value);
    }
    void sink(int n)//标记下沉
    {
        tree[2*n].change+=tree[n].change;
        tree[2*n].value+=tree[2*n].change;
        tree[2*n+1].change+=tree[n].change;
        tree[2*n+1].value+=tree[2*n+1].change;
        tree[n].change=0;
    }
public:
    void build(long long int *arr,int lenth)
    {
        tree=new node[lenth*2];
        members=lenth;
        buildp=arr;
        build(1,1,lenth);
    }
    long long int query(int begin,int end)
    {
        return query(1,begin,end);
    }
    void change(int target,long long int dv)
    {
        change(target,dv,1);
    }
    void areachange(int begin,int end,long long int dv)
    {
        areachange(begin,end,dv,1);
    }
};

四、例题

1.hdu 1166

         这是一题很裸的线段树，而且不需要用到区间求和，更加简单。


#include<string>
#include<cstdio>
#include<cstring>

using namespace std;

struct segtree
{
private:
    struct node//节点结构体，用来保存信息
    {
        node()
        {
            change=0;
        }
        long long int value;
        long long int change;
        int begin;
        int end;
    };
    node *tree;
    int members;
    long long int *buildp;
    void build(int n,int begin,int end)
    {
        int mid=(begin+end)/2;
        tree[n].begin=begin;
        tree[n].end=end;
        if(begin==end)//长度为1，赋值
        {
            tree[n].value=*buildp;
            ++buildp;
            return;
        }
        build(2*n,begin,mid);
        build(2*n+1,mid+1,end);//递归构造左右子节点
        update(n);
    }
    long long int query(int n,int begin,int end)
    {
        long long int q1=0,q2=0;
        int mid=(begin+end)/2;
        if(tree[n].begin>end||tree[n].end<begin)//查找区间和当前区间无交集
        {
            return 0;
        }
        if(tree[n].begin>=begin&&tree[n].end<=end)//当前区间为查找区间子集
        {
            return tree[n].value;
        }
        q1=query(2*n,begin,end);
        q2=query(2*n+1,begin,end);
        return q1+q2;
    }
    void change(int target,long long int dv,int n)
    {
        if(tree[n].begin==tree[n].end)//找到待更新节点，修改信息
        {
            tree[n].value+=dv;
            return;
        }
        int mid=(tree[n].begin+tree[n].end)/2;
        if(target<=mid)//未找到待更新节点，寻找正确的子节点继续寻找
        {
            change(target,dv,2*n);
        }
        else
        {
            change(target,dv,2*n+1);
        }
        update(n);
    }
    void update(int n)
    {
        tree[n].value=tree[2*n].value+tree[2*n+1].value;
    }
public:
    void build(long long int *arr,int lenth)//初始化
    {
        tree=new node[lenth*4];
        members=lenth;
        buildp=arr;
        build(1,1,lenth);
    }
    long long int query(int begin,int end)//区间查询
    {
        return query(1,begin,end);
    }
    void change(int target,long long int dv)//单点更新
    {
        change(target,dv,1);
    }
};

int main()
{
    int t,tn=1;
    scanf("%d",&t);
    while(tn<=t)
    {
        int n;
        scanf("%d",&n);
        long long int *arr=new long long int[n];
        for(int i=0;i<n;++i)
        {
            scanf("%d",&arr[i]);
        }
        printf("Case %d:\n",tn);
        ++tn;
        segtree tree;
        tree.build(arr,n);
        char command[6];
        long long int in1,in2;
        while(scanf("%s",command))
        {
            if(strcmp(command,"End")==0)
            {
                break;
            }
            else if(strcmp(command,"Query")==0)
            {
                scanf("%ld%ld",&in1,&in2);
                long long int rst=tree.query(in1,in2);
                printf("%ld\n",rst);
            }
            else if(strcmp(command,"Add")==0)
            {
                scanf("%ld%ld",&in1,&in2);
                tree.change(in1,in2);
            }
            else if(strcmp(command,"Sub")==0)
            {
                scanf("%ld%ld",&in1,&in2);
                tree.change(in1,-in2);
            }
        }
    }
    return 0;
}

2.hdu 1698

         这道题用到了区间查询，因为查询的是整条的和，所以只要输出第一个节点的value就行。而且这题我之前写的那种使用longlong并且把线段开始和结束的地址都存进节点的做法会mle，因此这里我把线段部分信息用函数参数传递，能节省空间。(p.s cin和cout会tle)

#include<iostream>
#include<string>
#include<cstdio>

using namespace std;

struct segtree
{
private:
    struct node//只保存节点值和变化标记
    {
        node()
        {
            change=0;
        }
        int value;
        int change;
    };
    node *tree;
    int members;
    int *buildp;
    void build(int n,int begin,int end)
    {
        int mid=(begin+end)/2;
        if(begin==end)
        {
            tree[n].value=*buildp;
            ++buildp;
            return;
        }
        build(2*n,begin,mid);
        build(2*n+1,mid+1,end);
        update(n);
    }
    int query(int n,int begin,int end,int bn,int en)//bn，en表示当前访问的节点区间的起始结束位置
    {
        int q1=0,q2=0;
        int mid=(begin+end)/2;
        int midn=(bn+en)/2;
        if(bn>end||en<begin)
        {
            return 0;
        }
        if(bn>=begin&&en<=end)
        {
            return tree[n].value;
        }
        if(tree[n].change!=0)
        {
            sink(n,bn,en);
        }
        q1=query(2*n,begin,end,bn,midn);
        q2=query(2*n+1,begin,end,midn+1,en);
        return q1+q2;
    }
    void areachange(int begin,int end,int dv,int n,int bn,int en)
    {
        if(bn>end||en<begin)
        {
            return;
        }
        if(bn>=begin&&en<=end) //当前区间为待更新区间的子集，添加标记
        {
            tree[n].change=dv;
            tree[n].value=tree[n].change*(en-bn+1);
            return;
        }
        if(tree[n].change!=0)
        {
            sink(n,bn,en);
        }
        int midn=(bn+en)/2;
        areachange(begin,end,dv,2*n,bn,midn);
        areachange(begin,end,dv,2*n+1,midn+1,en);
        update(n);
    }
    void update(int n)
    {
        tree[n].value=tree[2*n].value+tree[2*n+1].value;
    }
    void sink(int n,int bn,int en)//因为这题是用新值覆盖旧值，因此更新节点时直接用=就行
    {
        int midn=(bn+en)/2;
        tree[2*n].change=tree[n].change;
        tree[2*n].value=tree[2*n].change*(midn-bn+1);
        tree[2*n+1].change=tree[n].change;
        tree[2*n+1].value=tree[2*n+1].change*(en-midn);
        tree[n].change=0;
    }
public:
    void build(int *arr,int lenth)
    {
        tree=new node[lenth*4];
        members=lenth;
        buildp=arr;
        build(1,1,lenth);
    }
    int query(int begin,int end)
    {
        return query(1,begin,end,1,members);
    }
    void areachange(int begin,int end,int dv)
    {
        areachange(begin,end,dv,1,1,members);
    }
};

int main()
{
    int t,t0=1;
    scanf("%d",&t);
    while(t0<=t)
    {
        int n,m;
        int *arr;
        scanf("%d%d",&n,&m);
        arr=new int[n];
        for(int i=0;i<n;++i)
        {
            arr[i]=1;//一开始默认铜牌，初值为1
        }
        segtree tree;
        tree.build(arr,n);
        for(int i=0;i<m;++i)
        {
            int bg,en,cg;
            scanf("%d%d%d",&bg,&en,&cg);
            tree.areachange(bg,en,cg);
        }
        int rst=tree.query(1,n);
        printf("Case %d: The total value of the hook is %d.\n",t0,rst);
        ++t0;
    }
    return 0;
}


AuroraVeil
关注
基础之基础线段树
weixin_30294295的博客
10-27 63
这是关于线段树的某一实际应用。 其中涉及到，线段树的建立，线段树的查询（此题用的是查询之后的更新），当然正规全面的线段树还有修改等操作，我仅仅是万分之一吧。 转载一位大佬的博客 ：http://blog.csdn.net/zearot/article/details/48299459 本题大意是不断查询一个数组中一段连续长度的最大值与最小值的差，并输出。 下面为我的代码，比较拙劣。 查询...
线段树(基础)
quanzw0120的博客
05-23 307
最近训练线段树。因为一直听说胡浩大神的线段树模版很强很优美。照着模版敲了两遍以后意思基本上能明白。也能自己写出来。但是感觉自己没有深入的思考。很颓。相比起同级不看模版自己写出来的人感觉很惭愧。但是胡浩大神真的好强啊。那个模版简直完美。我感觉就是一句废话都没有。用最简单的语言把事情描述清楚了。真的很厉害。自己有时候写代码就是逻辑关系理不清楚。有时候很简单的事情被我写的很复杂。这方面以后多注意吧。昨天到
线段树基础
WA狂魔的博客
07-16 287
官方介绍： 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点，对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。 我对线段树的理解差不多就是有那么一个区间，一直二分到不能分，也就是下...
线段树基础知识
XiaoZheng的博客
03-11 1379
线段树的概念在一类问题中，我们需要经常处理可以映射在一个坐标轴上的一些固定线段，例如说映射在OX轴上的线段。由于线段是可以互相覆盖的，有时需要动态地取线段的并，例如取得并区间的总长度，或者并区间的个数等等。一个线段是对应于一个区间的，因此线段树也可以叫做区间树。线段树的构造思想 线段树是一棵二叉树，树中的每一个结点表示了一个区间[a,b]。 每一个叶子节点表示了一个单位区间。 根节点表示的是“整体”
线段树基础入门详解（适用于初学者）
lzoi_hmh的博客
07-10 600
由于以前看多了各种博客，关于线段树的讲解总是十分冗长，因此特此作文，大概讲解基本概念及操作，适用于初学者。初次写博，多多包涵一、线段树的概念 线段树在各个节点保存一条线段（数组中的一段子数组），主要用于高效解决连续区间的动态查询问题，由于二叉结构的特性，它基本能保持每个操作的复杂度为O(logn)。（看不懂不用管，没啥用） 这个图是线段树求数组array[2, 5, 1, 4, 9, 3]的区间最小和的例子（
线段树乘法模板（从基础线段树扩展）
04-22
以下是针对标题为“完整的线段树模板，基础模板”的资源描述，但特别强调了线段树乘法的应用： 资源标题：完整的线段树模板，基础模板（含乘法操作） 资源描述： 线段树（Segment Tree）是一种强大的数据结构，...
线段树的一种实现
12-25
线段树是一种高效的数据结构，常用于处理区间查询与更新问题。它的核心思想是将一个一维数组通过分治策略转化为一棵二叉树，每个节点代表一个区间的值，这棵树通常具有平衡性质，比如平衡二叉搜索树的特性。线段树在...
完整的线段树模板，基础模板
04-22
本资源提供了一个完整的线段树基础模板，旨在帮助开发者快速掌握并应用线段树解决实际问题。 特点： 基础性：适合初学者和有一定基础的开发者，从零开始理解线段树的构建和运作原理。 完整性：包含了线段树的构建...
基础线段树数据结构
qq_37464878的博客
03-07 520
1.线段树概念 线段树简单来说就是仅通过一个数组来描述一棵树。数组中每个元素存储树中对应节点存储的信息，不存储描述树的层次结构的信息。 注：这和树状数组的描述很像，因为线段树是一棵平衡二叉树（具体证明不在此演示）不需要特定存储层次结构信息，树状数组的父子节点具有特殊的与关系，也不需要存储特定的层次结构信息。 2.线段树的存储 2.1 线段树的核心性质 （每个节点存储着一个区间的区间和） 每个线段树节点存储两个边界值，表示区间的左右边界，除此之外应存储一个区间和变量，用于记录区间的和，当前节点的区间和等于
这可能是我见过最详细的线段树教程（基础+进阶）
csyifanZhang的博客
03-29 2388
一、简介线段树 psps : _此处以询问区间和为例。实际上线段树可以处理很多符合结合律的操作。（比如说加法，a[1]+a[2]+a[3]+a[4]=(a[1]+a[2])+(a[3]+a[4])） 线段树之所以称为“树”，是因为其具有树的结构特性。线段树由于本身是专门用来处理区间问题的（包括 RMQ 、 RSQ 问题等。 对于每一个子节点而言，都表示整个序列中的一段子区间；对于每个叶子节点而言...
基础线段树入门 NOI2017整数
Wall-E
08-11 247
世界如此美妙，你却如此暴躁，这样不好，不好                                                     ——吕秀才《武林外传》 题目大意 n次操作维护一个长度为n的二进制整数x，初始为丰，支持以下两种操作： 1.将这个整数加上ai · 2. 询问这个整数二进制意义下第ki位的值。 n&lt;=1000000  &lt;=1e9 b&lt;=30...
【D3.js Tidy tree绘制树形图,单棵树,左右树,平移,拖拽,树形中的天花板实现,源码实现】
『梁超』博弈人生-JAVA地盘
04-08 1634
D3.js Tidy tree绘制树形图,单棵树,左右树,平移,拖拽,树形中的天花板实现,源码实现
TidyTree:Javascript中毫不妥协的系统进化树
04-23
整洁树 由d3提供支持JavaScript中毫不妥协的系统进化树 创建此存储库供CDC计划使用，以与公共卫生监视相关项目进行协作，以支持CD​​C监视策略。 Github不是CDC托管的，而是CDC及其合作伙伴用来共享信息和在软件上进行协作。 TidyTree既是针对用户，又是针对开发人员的基础库。 启动应用程序 它旨在复制许多功能，尽管绝不是完美的替代品。 但是，它确实完全在浏览器中运行。 开发人员快速入门 首先导入库： < script src =" https://d3js.org/d3.v5.min.js " > </ script > < script src =" https://unpkg.com/tidytree@0.5.0/dist/tidytree.min.js " > </ script > （需要 ！） 然后将其粘贴在HTML script标签中： le
7.3.3 蓝桥杯基础数据结构之线段树—动态开点
tang7mj的博客
01-30 576
动态开点线段树是一种强大的数据结构，适用于处理大规模数据的区间问题。通过按需创建节点，它能够在保持效率的同时显著减少内存的使用。掌握这种数据结构对于参加蓝桥杯等算法竞赛的选手来说是非常有价值的。
航空公司客户满意度数据转换与预测分析Power BI案例研究
11-16
内容概要：本文档介绍了航空公司的业务分析案例研究，涵盖两个主要部分：a) 使用SSIS进行数据转换，b) 利用RapidMiner进行预测分析。这两个任务旨在通过改善客户满意度来优化业务运营。数据来源包括多个CSV文件，如flight_1.csv、flight_2.csv、type.csv、customer.csv 和 address.csv。第一部分要求学生创建事实表、客户维度表和时间维度表，并描述整个数据转换流程。第二部分则需要利用RapidMiner开发两种不同的模型（如决策树和逻辑回归）来预测客户满意度，并完成详细的报告，其中包括执行摘要、预测分析过程、重要变量解释、分类结果、改进建议和伦理问题讨论。 适合人群：适用于对数据科学和商业分析有一定基础的学生或专业人士。 使用场景及目标：本案例研究用于教学和评估，帮助学员掌握数据转换和预测建模的技术方法，提高客户满意度和业务绩效。目标是通过实际操作加深对相关工具和技术的理解，并能够将其应用于实际业务中。 其他说明：此作业占总评的40%，截止时间为2024年10月25日16:00。
课题设计-基于MATLAB平台的图像去雾处理+项目源码+文档说明+课题介绍+GUI界面
11-16
一、课题介绍 现在我国尤其是北方城市，工业发达，废弃排放严重，这使得雾霾越来越厉害，让能见度极低。这严重影响了我们的交通系统，导航系统，卫星定位系统等，给人民出行，工作带来极大的不便利。目前市场上高清拍摄设备虽然可以让成像清晰点，但是造价高昂。如果有一套软件处理系统，可以实时地处理含雾的图像，让成像去雾化，让图像变得清晰，将会很受欢迎。 该课题是基于MATLAB平台的图像去雾处理，配备一个人机交互GUI界面，可以选择全局直方图均衡化，Retinex算法，同态滤波，通过对比处理前后的图像的直方图，而直方图是一副图像各灰度值在0-256的分布个数的表，信息论已经整明，具有均匀分布直方图的图像，其信息量是最大的。 二、算法介绍 ①全局直方图均衡化：通俗地理解就是，不管三七二十一，直接强行对彩色图像的R,G,B三通道颜色进行histeq均衡处理，然后进行三通道重组； ②Retinex算法：通俗地讲就是，分离R,G,B三通道，对每个通道进行卷积滤波。
微信支付V2版本的支付接口，java的SDK
最新发布
11-16
微信支付V2版本的支付接口，java的SDK
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值