线段树基础知识

最新推荐文章于 2023-05-11 21:23:17 发布
最新推荐文章于 2023-05-11 21:23:17 发布
阅读量514 收藏 1
点赞数
分类专栏： 算法学习心得 文章标签： insert tree colors null c struct

线段树基础知识

从简单说起，线段树其实可以理解成一种特殊的二叉树。但是这种二叉树较为平衡，和静态二叉树一样，都是提前已经建立好的树形结构。针对性强，所以效率要高。这里又想到了一句题外话：动态和静态的差别。动态结构较为灵活，但是速度较慢；静态结构节省内存，速度较快。

接着回到线段树上来，线段树是建立在线段的基础上，每个结点都代表了一条线段[a , b]。长度为1的线段成为元线段。非元线段都有两个子结点，左结点代表的线段为[a , (a + b ) / 2]，右结点代表的线段为[( a + b ) / 2 , b]。

图一就是一棵长度范围为[1 , 10]的线段树。

长度范围为[1 , L] 的一棵线段树的深度为log ( L - 1 ) + 1。这个显然，而且存储一棵线段树的空间复杂度为O（L）。

线段树支持最基本的操作为插入和删除一条线段。下面已插入为例，详细叙述，删除类似。

将一条线段[a , b] 插入到代表线段[l , r]的结点p中，如果p不是元线段，那么令mid＝（l＋r）/2。如果amid，那么将线段[a , b] 也插入到p的右儿子结点中。

插入（删除）操作的时间复杂度为O （ Log n ）。

上面的都是些基本的线段树结构，但只有这些并不能做什么，就好比一个程序有输入没输出，根本没有任何用处。

最简单的应用就是记录线段有否被覆盖，并随时查询当前被覆盖线段的总长度。那么此时可以在结点结构中加入一个变量int count；代表当前结点代表的子树中被覆盖的线段长度和。这样就要在插入（删除）当中维护这个count值，于是当前的覆盖总值就是根节点的count值了。

另外也可以将count换成bool cover；支持查找一个结点或线段是否被覆盖。

例题1（ZJU1610 Count The Colors 线段树基本应用题目）

给出在线段[0,8000]上的若干次涂色，问最后能看见哪些颜色，并统计能看到多少段。

解析

就这个题目而言，方法很多，而且数据范围不大，但我们由线段树的角度来解决这个问题。

建立一棵代表线段[0,8000]的线段树，涂色操作就是将[a , b]涂成颜色c。最后做统计。

结构如下：

struct TNode {

        int     left , right;

        int     col;

        TNode   *LeftChild , *RightChild;

};

col 有几种情况，如果col为－1，代表了尚未涂色，－2代表了是混和色，就是说这条线段并不是单一的颜色。其他情况，便是这条线段都是这个颜色的了。

线段树的第一种变化

基本的线段树代表的是线段，如果我们把线段离散成点来看，那么线段树可以变化成一种离散类型线段树。

这里可以有两种理解。一种离散关系可以是连续的线段的点，比方说在一条直线上放置的连续小球的着色问题；另一种则是完全将线段离散化分成若干小段，对每一段小段做为元线段来建立线段树，这种线段树可以支持实数划分类型的线段。

例题2（ZJU2451 Minimizing maximizer ）

Andy想要得到一组数中的最大值。会有一系列的操作Sorter(i[1], j[1]), ..., Sorter(i[k], j[k])。作用是将数组中的第i[k]个数字到第j[k]个数字排序。按照输入给出的顺序，你可以选择要不要执行这个操作。问题是最少需要多少步操作，可以求出这个最大值。题目保证可以求出。

多组数据。

第一行为两个数字N，M。表示N个数，M个操作。

接下来M行，每行描述一个操作i[k] , j [k]。

对于每组数据，输出最少需要多少次操作分离得到最大值。

每组数据一行。

解析

由于要将最大的数字分离到最后的一位，如果我们考虑将数组看成一条[1,n]的线段，而每项操作也看成是从[i[k],j[k]]的线段，那么就是要求按照输入的顺序，将线段[1,n]从左到右依次覆盖掉，问题变成求最小的覆盖线段总数。

考虑最基本的规划方法，用Opt [k] 表示覆盖掉 [1,k]的线段最少需要的步数，那么状态转移方程为：

Opt [k] = min { Opt [d] + 1 | j [p] = k && d >= i [p] && d <= j [p] && k > 1 }

Opt [1] = 0;

最后的答案就是Opt [n]了，但是考虑时间复杂度，是O（m^2）级别的，m最大为500000，超时无疑。但是这里我们看到了规划的决策集合是一条连续的线段，是要在这条线段上面取得最小值，那么线段树的结构就正好适合在这里应用了。

由于这里最小的单位是一个点，所以我们采取线段树的第一种变化，把元线段设置为单位点，即[k,k]。在规划的时候维护线段树即可。

线段树结点结构中，需要加入的元素是int minstep 代表最少需要用到的覆盖线段数目可以覆盖到当前结点所代表的线段中。

例题3（PKU2104K-th Number）

给出一个大小为n的数组A[]，给出m个问题（1 <= n <= 100 000, 1 <= m <= 5 000）。问题格式为Q（i，j，k），询问从A[i]到A[j]第k大的元素是什么。A[]中的数各不相同。

解析

由于仍旧是离散的整数问题，我们依旧采取第一种变化。看到题目，最基本的想法就是排序然后求第k个数了，但是时限上不能满足要求。

线段树的最强大方面就是将一组数（一条线段）放到一起处理。每层树需要的线段数目不会超过4，而深度为logn，所以最后操作的复杂度会是O(logn)。

但是仅仅应用线段树还是不够的，即使我们知道了需要处理的线段是那些，但是由于线段过多，也无法准确求出第k个元素究竟是什么。这里二分策略就派上了用场。我们用二分枚举第k个数字P，然后再在所要的线段中找到枚举的P所在的位置，同样是用二分的策略。所以复杂度是O(mlognlognlogn)。

我们在找P所在的位置的时候需要用到二分策略，也就是说，我们需要将线段所代表的结点排序，这里可以将每一层的所有数放到一起，统一成一个数组SortArray[depth][]。其实也可以理解成将归并排序的每个步骤记录下来。

线段树的第二种变化 （树状数组）

在结构上对线段树进行改变，可以得到线段树的另一种变化。

用O（n）的一维数组构造出线段树，无其他附加空间。比方说，一棵从[0,L]的线段树表示为TNode Tree[L];

这里应用二进制将树进行划分。将整数R的二进制表示中的最后一个1换成0，得到数L。Tree[R]代表的线段就是[L,R]。例如：6的二进制表示为（110）2将最后一个1换成0即为（100）2＝4，所以Tree[6]代表的线段就是[4,6]。

析出数R的最后一位1的方法是：LowBit（R）＝R^~R。

包含点L的一系列数为x1,x2,……，这里x1=R，x2=x1+LowBit (x1)，x3=x2+LowBit(x2)，……

这种线段树的优点在于：

1． 节省空间。完全线段长度的空间，无需左右指针，无需左右范围。

2． 线段树查找严格log(R)，因为二进制的每位查找一遍。

3． 状态转移快，操作简单。

4． 扩展到多维较为容易。

缺点：

1．随意表示线段[a,b]较为困难。

这种线段树适用于：

1． 查找线段[0,L]的信息。

2． 求线段[a,b]的和（应用部分和做差技术）。

// problem zju 1610

// Segment Tree

#define NoColor -1

#define MulColor -2

＃i nclude

＃i nclude

int     Len;

struct TNode {

        int     left , right;

        int     col;

        TNode   *LeftChild , *RightChild;

        void    Construct ( int , int );

        void    Insert ( int , int , int );

        void    Calculate ();

} Tree [16000] , *Root = &Tree [0];

int     CalColor [8001] , Many [8001];

void    TNode :: Construct ( int l , int r )

{

        left = l; right = r;

       if ( l + 1 == r ) { LeftChild = NULL; RightChild = NULL; return; }

        int     mid = ( l + r ) >> 1;

        LeftChild = &Tree [Len ++];

        RightChild = &Tree [Len ++];

        LeftChild->Construct( l , mid );

        RightChild->Construct( mid , r );

}

void    TNode :: Insert ( int l , int r , int c )

{

        if ( col == c ) return;

        if ( l == left && r == right ) { col = c; return; }

        int     mid = ( left + right ) >> 1;

        if ( col != MulColor ) { LeftChild -> col = col; RightChild -> col = col; }

        col = MulColor;

        if ( r <= mid ) { LeftChild -> Insert ( l , r , c ); return; }

        if ( l >= mid ) { RightChild -> Insert ( l , r , c ); return; }

        LeftChild -> Insert ( l , mid , c );

        RightChild -> Insert ( mid , r , c );

}

void    TNode :: Calculate ()

{

        if ( col != MulColor && col != NoColor ) {

                int     i;

                for ( i = left; i < right; i ++ ) CalColor [i] = col;

        }

        if ( col == MulColor ) { LeftChild -> Calculate (); RightChild -> Calculate (); }

}

main ()

{

        int     Total , a , b , c , i , t;

        Len = 1; Tree [0].Construct( 0 , 8000 );

//        printf ( "After Construct the Tree , Len = %d/n" , Len );

        while ( scanf ( "%d" , &Total ) != EOF ) {

                Tree [0].col = NoColor;

                while ( Total ) {

                        scanf ( "%d %d %d" , &a , &b , &c );

                        Root -> Insert( a , b , c );

                        Total --;

                 }

                memset ( CalColor , 0xff , sizeof ( CalColor ) );

                memset ( Many , 0 , sizeof ( Many ));

                Root -> Calculate ();

                t = -1;

                for ( i = 0; i <= 8000; i ++ ) {

                         if ( CalColor [i] == t ) continue;

                        t = CalColor [i];

                        if ( t != -1 ) Many [t] ++;

                }

                for ( i = 0; i <= 8000; i ++ ) if ( Many [i] )

                        printf ( "%d %d/n" , i , Many [i] );

                printf ( "/n" );

        }

}

 

// Problem zju2451
// DP with Segment Tree
#include <stdio.h>
#define MAX     50000
 
 
int     Len;
struct  TNode {
        int     left , right;
        int     minstep;
        TNode   *LeftChild , *RightChild;
        void    Construct ( int , int );
        void    Insert ( int , int );
        int     GetRank ( int , int );
}       STree [MAX * 2 + 2] , *Root = &STree [0];
 
 
int     N , M;
 
 
void    TNode :: Construct ( int l , int r )
{
        left = l; right = r; minstep = 999999;
        if ( l == r ) { LeftChild = NULL; RightChild = NULL; return; }
        int     mid = ( l + r ) >> 1;
        LeftChild = &STree [Len ++];
        RightChild = &STree [Len ++];
        LeftChild->Construct ( l , mid );
        RightChild->Construct( mid + 1 , r );
}
 
 
void    TNode :: Insert ( int p , int x )
{
        if ( x < minstep ) minstep = x;
        if ( left == right ) return;
 
 
        if ( p <= ( left + right ) >> 1 ) LeftChild->Insert( p , x );
                else RightChild->Insert( p , x );
}
 
 
int     TNode :: GetRank ( int l , int r )
{
        if ( l == left && r == right ) return minstep;
        int     mid = ( left + right ) >> 1;
        if ( r <= mid ) return LeftChild->GetRank( l , r );
        if ( l > mid ) return RightChild->GetRank( l , r );
        int     ret1 , ret2;
        ret1 = LeftChild->GetRank( l , mid );
        ret2 = RightChild->GetRank( mid + 1 , r );
        return ret1 < ret2 ? ret1 : ret2;
}
 
 
main ()
{
        int     i , a , b , p;
        while ( scanf ( "%d %d" , &N , &M ) != EOF ) {
                Len = 1; Root->Construct( 1 , N );
 
 
                Root->Insert ( 1 , 0 );
 
 
                for ( i = 0; i < M; i ++ ) {
                        scanf ( "%d%d" , &a , &b );
                        if ( a < b ) {
                                p = Root->GetRank ( a , b - 1 );
                                Root->Insert ( b , p + 1 );
                        }
                }
                printf ( "%d/n" , Root->GetRank( N , N ) );
        }
}
 
 


 
 
 
 
// PKU 2104
// Segment Tree && Binnary Search
 
 
#include <stdio.h>
#define MAX     100000
 
 
int     len;
struct  TNode {
        int     left , right;
        char    depth;
        TNode   *LeftChild , *RightChild;
        void    construct ( int , int , int );
        int     GetRank ();
}       Node [2 * MAX + 2];
 
 
int     SortArray [18] [MAX + 2];
 
 
int     Key , ls , rs;
void    TNode :: construct ( int l , int r , int dep )
{
        left = l; right = r; depth = dep;
        if ( left == right ) {
                scanf ( "%d" , &SortArray [dep] [l] );
                return;
        }
        int     mid = ( l + r ) >> 1;
        LeftChild = &Node [len ++];
        LeftChild->construct( l , mid , dep + 1 );
        RightChild = &Node [len ++];
        RightChild->construct( mid + 1 , right , dep + 1 );
 
 
        int     i = left , j = mid + 1 , k = left;
        while ( i <= mid && j <= r ) {
                if ( SortArray [dep + 1] [i] < SortArray [dep + 1] [j] )
                        SortArray [dep] [k ++] = SortArray [dep + 1] [i ++];
                        else
                        SortArray [dep] [k ++] = SortArray [dep + 1] [j ++];
        }
        while ( i <= mid ) SortArray [dep] [k ++] = SortArray [dep + 1] [i ++];
        while ( j <= right ) SortArray [dep] [k ++] = SortArray [dep + 1] [j ++];
}
 
 
int     TNode :: GetRank ()
{
        if ( ls <= left && right <= rs ) {
                if ( SortArray [depth] [left] >= Key ) return 0;
                if ( SortArray [depth] [right] < Key ) return right - left + 1;
                if ( SortArray [depth] [right] == Key ) return right - left;
                int     low = left , high = right , mid;
                while ( low + 1 < high ) {
                        mid = ( low + high ) >> 1;
                        if ( SortArray [depth] [mid] < Key ) low = mid;
                                else high = mid;
                }
                return low - left + 1;
        }
        int     ret = 0;
        if ( ls <= LeftChild->right ) ret += LeftChild->GetRank();
        if ( RightChild->left <= rs ) ret += RightChild->GetRank();
        return ret;
}
 
 
main ()
{
        int     N , Q , i;
        int     low , high , mid , Index;
        scanf ( "%d%d" , &N , &Q );
        len = 1; Node [0].construct( 0 , N - 1 , 0 );
        for ( i = 0; i < Q; i ++ ) {
                scanf ( "%d%d%d" , &ls , &rs , &Index );
                ls --; rs --;
                low = 0; high = N;
                while ( low + 1 < high ) {
                        mid = ( low + high ) >> 1;
                        Key = SortArray [0] [mid];
                        if ( Node [0].GetRank() >= Index ) high = mid;
                                else low = mid;
                }
                printf ( "%d/n" , SortArray [0] [low] );
        }
}

lmsnju
关注
专栏目录
线段树基础知识详解
weixin_30633507的博客
08-05 170
INTRODUCTION: 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N， 实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。--百度百科 首先来看一类题：洛谷P3372 给定一个...
主席树 可持久化线段树基础知识入门详解
ZSJZ_liuzian的博客
08-17 1716
主席树 可持久化权值线段树，又称为主席树。是权值线段树的进阶版，如果不会权值线段树可以先学习一下。 【权值线段树】基础入门知识详解 是什么 它可以看作是多棵权值线段树，但它所占的空间很小！！！ 具体不容易解释，可以先往后面的内容浏览。 为什么要用它 对于一棵权值线段树，我们要往里面加入nnn个数。容易知道，每加入一个数就会更新一遍线段树。 当我们想要知道每次更新后的权值线段树的状态...
关于线段树基础
百般回首曾经的相遇，留下的只是一缕残忆
04-02 1211
线段树（c++） 需求： 必须：二分法，树的基础 拓展：补码，反码，移码，lowbit() 建议先看看这个： https://blog.csdn.net/zearot/article/details/52280189 了解什么是线段树及用途 线段树，类模板题 Just a Hook http://acm.hdu.edu.cn/showproblem.php?pid=1698 #include &l...
线段树基础知识（续）
XiaoZheng的博客
03-23 725
经过上次线段树的基本讲解，这次我们就专门来看几道例题。 --------------------------------------------------------------------------------------------------------- 问题 D(1911): 【高级数据结构】线段的条数 题目描述 无限长的X轴上从下向上依次叠放一定长度某种
线段树基础知识+单点更新、区间更新模板
欢迎访问方偲的博客
01-04 180
本文根据网页链接的视频进行学习，感谢up主！ 线段树适用情况 题目给了一个数组（例如[1,5,4,1,6]，通常数据比较多），对其中的部分区间进行多次更新，然后对部分区间进行多次查询（查询区间内的最大值/最小值/和），普通做法会超时，应使用线段树来做～ 抽象化建树 建立二叉树，把数组存到二叉树中去 （例如，） 然后从叶子结点很容易得到我们需要查询的内容，然后不断将查询的结果往上传 （...
线段树基础知识----（基础数据结构）--（一）
a15139111362的博客
07-24 155
1.定义 引入：为什么要使用线段树而不用数组模拟呢？ answer:因为有些题用数组来做就要超时，用线段树的O(log(n))的时间复杂度刚好可以求解 毫无疑问线段树是一种数据结构，但是它实际是一个类似树状的链表结构（个人认为） ///还是要正经一点（照搬教科书）----------- / ///////////////////////////////////////////...
线段树练习题集
UncleJokerly
04-28 2292
线段树题目整合 1.hdu1166 敌兵布阵 更新节点,区间求和。 2.hdu1754 I Hate It 更新节点,区间最值. .3.hdu1698 Just a Hook 成段更新,总区间求和. .4.hdu1394 Minimum Inversion Number 更新节点,区间求和 .5.hdu1779（这个爆炸了，别做了） 成段更新,区间最值 .6.pku...
线段树详解 （原理，实现与应用）
热门推荐
岩之痕
09-09 14万+
线段树详解 By 岩之痕 一：综述 线段树是一种可以快速进行区间修改和区间查询的数据结构。点修改，区间修改和区间查询的复杂度都是O(log2(n)) 并且，线段树可以维护很多种类的信息。说到线段树就不得不提一下树状数组，树状数组维护的信息必须满足区间减法，因为树状数组只是维护1到X的信息，通过相减来得到区间信息，代码简单而且速度快，占用空间又少于线段树，所以一般情况下可以用树状数组的地方就
线段树详解
最新发布
good good study, day day up!
05-11 912
线段树
线段树六题
06-06
线段树的实现需要深厚的编程基础，包括递归、数据结构（特别是二叉树）以及对应的算法逻辑处理能力。针对实际的竞赛题目，还需要根据题目特性和数据规模来调整线段树的实现细节，比如懒惰传播策略的使用、节点合并...
线段树1代码资源（普通/指针线段树,分块,树状数组）
01-31
1. **普通线段树**：普通线段树是线段树的基础形态，通过数组存储节点，每个节点代表一个区间的最大值或最小值，或者区间的和。初始化时，从底向上构造线段树，每次将两个子节点的信息合并到父节点。在线段树上进行...
浅谈线段树——基础篇
jay_zai的博客
07-24 501
本文先讲解线段树的基础知识及其运用，更多进阶内容以后有时间再写（等我学会了再说 ）
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 9034
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）
北豼不太皮的博客
02-21 3581
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础 一、学习目标 二、了解单片机STM32F401RET6 4、STM32F401RE特征 三、C语言基础 1.数据类型 常用2的次方： 2^7 = 128 2^8 = 256 2^15 = 32768 2^16= 65536 51单片机常见的数据类型： char: 占内存1字节 取值范围：-128~127 -2^7 ~ 2
Android开发（1） | Fragment 的应用——新闻应用
Jormungand_V的博客
02-21 7090
文章目录 news_item.xml： <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/news_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:lines="1" android:ellipsize="
系统学习 TypeScript（四）——变量声明的初步学习
编程三昧
02-25 1732
认识了 TypeScript 中的基础类型，接下来当然是变量声明的相关学习了，我在这里记录一下我学习过程中的一些总结。
清除浮动的五种方法
weixin_52212950的博客
02-22 2702
为什么要清除浮动？因为往往浮动后的子元素因为脱离了标准流，不能自动撑起父元素的高度，所以会对后续布局产生影响，对此清除浮动不如理解为清除浮动产生的影响更为合理。 例如：我们设置了两个盒子如图所示，粉色为父盒子，只有宽度没有高度，蓝色盒子有宽有高，粉色盒子的高由蓝盒子的高度撑开。 但是给蓝色的子盒子设置了左浮动后，脱离了标准流，无法再撑开粉盒子，可以看到粉盒子高度变成了0； 清除浮动有五种方法： 直接设置父元素的高度 额外标签法 单伪元素法 双伪元素法 ove.
HTML实现学习网站首页
做技术，坚持才是最重要的，一时的热情只是暂时的进步
02-20 4154
项目访问 reset.css /* http://meyerweb.com/eric/tools/css/reset/ v2.0 | 20110126 License: none (public domain) */ html, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, big, cite, code, del
快速掌握线段树基础与应用：构建区间操作神器
首先，线段树的基本概念建立在每个结点代表一条线段的基础之上。每个结点通常表示一个区间，如[a, b]，其中a和b分别代表区间的起始和结束位置。对于线段树，特别关注的是元线段，长度为1的线段被视为基本单位。非元...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值