数据结构第十一期——线段树的原理和应用

目录

一、前言

二、线段树的概念

1、区间最值问题RMQ (Range Minimum/Maximum Query)

（1）暴力法

（2）高效的办法：线段树

（3）把数列放在二叉树上

（4）查询最小值的复杂度

2、线段树的构造

3、线段树的树结构

三、例题应用

1、最大数（lanqiaoOJ题号826）

（1）初始建一棵空树 build(p, pl, pr)

（2）更新线段树 update()

（3）查询

2、选数异或（2022年省赛，lanqiaoOJ题号2081）

（1）暴力（40%）

（2）动态规划+字典（100%）

（3）线段树（100%）

---

一、前言

本文讲了线段树的概念和两道例题，建议自己要再多看几眼代码进行思考，第一遍其实我还没有理解透彻为什么要这么做，多看代码多思考。

二、线段树的概念

• 考核最多的高级数据结构
• 从初级水平到中级水平的标志：在掌握线段树之后才能说 “我真正进入了算法竞赛的大门。”
• 应用背景：区间修改、区间查询、区间合并。

1、区间最值问题RMQ (Range Minimum/Maximum Query)

长度为 n 的数列 {a1, a2, ..., an}

（1）求最值：给定 i,j<=n，求 {ai, ...,aj} 区间内的最值。

（2）修改元素：给定 k 和 x，把 a 改成 x。

（1）暴力法

用普通数组存储数列：

查询最值：区间内的最值，复杂度 O(n)

修改元素：复杂度 O(1)

暴力法复杂度：如果有 m 次 “修改元素+查询最值”，总复杂度 O(mn)。

m,n>10^5，O(mn)>10^10

（2）高效的办法：线段树

• 用线段树，对 n 个数进行 m 次 “修改元素+查询最值”，复杂度：O(mlogn)
• 线段树：一种用于区间处理的数据结构。
• 基于二叉树。

（3）把数列放在二叉树上

例：查询 {1, 2, 5, 8, 6, 4, 3} 的最小值

首先，把数放在二叉树上：

每个结点上的数字是这个结点的子树的最小值。

（4）查询最小值的复杂度

查询某个区间的最小值，只需要 O(logn) 次。

思考：如何在二叉树上定位某个区间?

2、线段树的构造

• 线段树是建立在线段（或者区间）基础上的树，树的每个结点代表一条线段 (或者称为区间) [L, R]。
• 例：线段 [1, 5] 的线段树。

线段 [L,R]：L是左子结点，R是右子结点。

（1）L = R。它是一个叶子结点。

（2）L < R。有两个儿子，左儿子代表区间 [L,M]，右儿子代表区间 [M+1,R]，其中 M = (L + R) / 2。

【线段树的复杂度】

• 每步处理，从二叉树的根结点开始到最下一层，最多需要更新 log4n 个结点，复杂度 O(logn)；
• 一共有 n 个数字需要处理，总复杂度 O(nlogn)。
• 线段树把 n 个数按二叉树进行分组，每次更新有关的结点时，这个结点下面的所有子结点都隐含被更新了，从而大大地减少了处理次数。

【区间查询】

• 区间查询问题 (最值、区间和) 是线段树的一个基本应用场景。
• 以数列 {1, 4, 5, 8, 6, 2, 3, 9, 10, 7} 为例。
• 首先建立一棵用完全二叉树实现的线段树，用于查询任意子区间的最小值。
• 每个结点上圆圈内的数字是这棵子树的最小值。
• 圆圈旁边的数字，例如根结点的 "1:[1,10]"，1 表示结点的编号，[1,10] 是这个结点代表的元素范围，即第 1 到第 10 个元素。

【查询任意区间 [i, j] 的最小值】

• 例：查区间 [4, 9] 的最小值
• 递归查询到区间 [4, 5]、[6, 8]、[9, 9]，见图中画横线的线段，得最小值 min{6, 2, 10}=2。查询在 O(logn) 时间内完成。
• 线段树高效的原因：每个结点的值，代表了以它为根的子树上所有结点的值。查询这个子树的值时，不必遍历整棵树，而是直接读这个子树的根。
• m 次 “单点修改+区间查询” 的总复杂度 O(mlogn)。

3、线段树的树结构

用数组 tree[] 实现一棵满二叉树。每个结点的左右儿子：

左儿子：p<<1，即 p*2。

例：根 tree[1] 的左儿子是 tree[2]，结点 tree[12] 的左儿子是 tree[24]。

右儿子：p<<1|1，即 p*2+1。

例：根 tree[1] 的右儿子是 tree[3]，结点 tree[12] 的右儿子是 tree[25]。

注：p<<1|1，是先左移再按位或

#定义根节点是tree[1]，即编号为1的结点是根
tree=[0]*(N<<2)     #用tree[i]记录线段i的最值
#父子关系，p是父
tree[p<<1]  #左儿子，编号p*2
tree[p<<1|1]    #右儿子，编号p*2+1

【线段树的修改】

点修改：在线段树中每次只修改一个点。

区间修改：每次修改一个区间的所有数。

重点在区间修改

• 给定 n 个元素 {a1，a2，...，an}：
• 修改（加）：给定 i,j<=n，把 { ai, ..., aj } 区间内的每个元素加 v。
• 查询：给定 L,R<=n，计算 {aL, ..., aR} 的区间和。

三、例题应用

1、最大数（lanqiaoOJ题号826）

【题目描述】

维护一个数列，要求提供以下两种操作：

1、查询操作。

语法：Q L

功能：查询当前数列中末尾 L 个数中的最大的数，并输出这个数的值。

限制：L 不超过当前数列的长度。(L>0)

2、插入操作。

语法：A n

功能：将 n 加上 t，其中 t 是最近一次查询操作的答案（如果还未执行过查询操作，则 t=0)，并将所得结果对一个固定的常数 D 取模，将所得答案插入到数列的末尾。

限制：n 是整数 (可能为负数) 并且在长整范围内。

注意：初始时数列是空的，没有一个数。

【输入描述】

第一行两个整数，M 和 D，其中 M 表示操作的个数，D 如上文中所述。接下来的 M 行，每行一个字符串，描述一个具体的操作。语法如上文所述。其中，1<=M<=2×10^5，1<=D<=2×10^9。

【输出描述】

对于每一个查询操作，你应该按照顺序依次输出结果，每个结果占一行。

【完整代码】

N=100001
INF=0x7FFFFFFF
tree=[0]*(N<<2)     #4倍
def bulid(p,pl,pr):     #每一个结点都是极小的一个值
    if pl==pr:
        tree[p]=-INF    #本题是求最大值，把每一个结点赋予极小值
        return
    mid=(pl+pr)>>1
    bulid(p<<1,p1,mid)  #p<<1是左儿子
    bulid(p<<1|1,mid+1,pr)  #p<<1|1是右儿子
    tree[p]=max(tree[p<<1],tree[p<<1|1]) #push_up,这里体现了线段树的一个精髓
def update(p,p1,pr,L,R,d):
    if L<=pl and pr<=R:
        tree[p]=d
        return
    mid=(pl+pr)>>1
    if L<=mid:
        update(p<<1,pl,mid,L,R,d)
    if R>mid:
        update(p<<1|1,mid+1,pr,L,R,d)
    tree[p]=max(tree[p<<1],tree[p<<1|1]) #push_up
    return
def query(p,pl,pr,L,R):
    res=-INF
    if L<=pl and pr<=R:
        return tree[p]
    mid=(pl+pr)>>1
    if L<=mid:
        res=max(res,query(p<<1,pl,mid,L,R))
    if R>mid:
        res=max(res,query(p<<1|1,mid+1,pr,L,R))
    return res
 
m,D=map(int,input().split())
bulid(1,1,N)    #不用bulid,这样写也行；update(1,1,N,1,N,-INF)
cnt=0
t=0
for i in range(m):
    op=list(input().split())
    if op[0]=='A':
        cnt+=1
        update(1,1,N,cnt,cnt,(int(op[1]+t))%D)
    if op[0]=='Q':
        t=query(1,1,N,cnt-int(op[1])+1,cnt)
        print(t)

（1）初始建一棵空树 build(p, pl, pr)

• build(p, pl,pr)：p是tree[p]，即建立以 tree[p] 为根的一棵子树，它代表区间 [pl, pr]。
• build() 函数是一个递归函数，递归到最底的叶子结点，赋初始值 tree[p] = -INF，即一个极小的值。本题是求最大值，把每个结点赋值为极小。
• 建树用二分法，从根结点开始逐层二分到叶子结点。

• 作用：把底层的值递归返回，赋值给上层结点。线段树的每个结点，代表了以这个结点为根的子树的最大值 (本题是求最大值，有的题目是求区间和)
• push_up 利用递归函数的回溯，完成了这一任务。

def bulid(p,pl,pr):     #每一个结点都是极小的一个值
    if pl==pr:
        tree[p]=-INF    #本题是求最大值，把每一个结点赋予极小值
        return
    mid=(pl+pr)>>1
    bulid(p<<1,p1,mid)  #p<<1是左儿子
    bulid(p<<1|1,mid+1,pr)  #p<<1|1是右儿子
    tree[p]=max(tree[p<<1],tree[p<<1|1]) #push_up,这里体现了线段树的一个精髓

初始建树 build() 函数并不是必须的，可以不用。

线段树代码中一定会有一个 update() 函数，作用是更新一个区间，它可以替代 build() 的功能。

（2）更新线段树 update()

update(p, pl, pr, L, R, d) 是通用模板。p 表示结点 tree[p]，pl 是左子树，pr 是右子树。区间 [L, R] 是需要更新的区间。d 是修改或更新。

本题的更新功能是新增一个结点，有两个步骤。

1）把这个结点放在二叉树的叶子上。在本题中这样使用：

update(1, 1, N, cnt, cnt, (x+t)%D)；

作用：把 [cnt, cnt] 区间的值赋值为 (x+t)%D。

因为 [cnt, cnt] 这个区间只包含 tree[cnt] 一个结点，所以它是对新增叶子结点 tree[cnt] 赋值。

2）新增这个结点导致它上层结点的变化，需要把变化上传到上层结点。通过 push_up，把变化递归到上层。

def update(p,p1,pr,L,R,d):
    if L<=pl and pr<=R:
        tree[p]=d
        return
    mid=(pl+pr)>>1
    if L<=mid:
        update(p<<1,pl,mid,L,R,d)
    if R>mid:
        update(p<<1|1,mid+1,pr,L,R,d)
    tree[p]=max(tree[p<<1],tree[p<<1|1]) #push_up
    return

（3）查询

查询区间 [L, R] 的最大值。函数 query(p, pl, pr, L, R) 查询以 p 为根的子树，这棵子树内区间 [L, R] 的最大值。

1）如果这棵子树完全被 [L, R] 覆盖，也就是说这棵子树在要查询的区间之内，那么直接返回 tree[p] 的值。这一步体现了线段树的高效率。如果不能覆盖，那么需要把这棵子树二分，再继续下面两步的查询。

2）如果 L 与左部分有重叠。

3）如果 R 与右部分有重叠。

def query(p,pl,pr,L,R):
    res=-INF
    if L<=pl and pr<=R:
        return tree[p]
    mid=(pl+pr)>>1
    if L<=mid:
        res=max(res,query(p<<1,pl,mid,L,R))
    if R>mid:
        res=max(res,query(p<<1|1,mid+1,pr,L,R))
    return res

2、选数异或（2022年省赛，lanqiaoOJ题号2081）

【题目描述】

给定一个长度为 n 的数列 A1, A2, ...,  An 和一个非负整数 x，给定 m 次查询，每次询问能否从某个区间 [l, r] 中选择两个数使得他们的异或等于 x。

【输入格式】

输入的第一行包含三个整数 n, m, x。第二行包含 n 个整数 A1, A2, ...., An。接下来 m 行，每行包含两个整数 li, ri 表示询问区间 [li, ri]。

【输出格式】

对于每个询问，如果该区间内存在两个数的异或为 x 则输出 yes，否则输出 no。

【评测用例规模与约定】

对于 20% 的评测用例，1<=n,m<=100；

对于 40% 的评测用例，1<=n,m<=1000；

对于所有评测用例，1<=n,m<=100000，0<=x<2^20，1<=li<=ri<=n，0<=Ai<2^20

（1）暴力（40%）

用combinations，遍历 [L,R] 内的任意 2 个数的组合

import itertools
def two(l,r):
    b=itertools.combinations(a[l:r+1],2)
    for i in b:
        if i[0]^i[1]==x:
            return 'yes'
    return 'no'
 
n,m,x=map(int,input().ssplit())
a=[0]+list(map(int,input().split()))    #a[0]不用
c=[]
for i in range(m):
    c.append(list(map(int,input().split())))
for i in c:
    print(two(i[0],i[1]))

（2）动态规划+字典（100%）

• 设 ai 右边符合要求的是 aj
• 设 a(i+1) 右边符合要求的是 ak
• 若 k

定义字典 mp，mp 的键是 a[i]，对应的值是 i。

• 第 7 行：把 a[i] 映射到 i。
• 第 8~9 行：找到距离 a[i] 的符合题目要求的数的最近位置。
• 第 10 行：判断查询的区间内，有没有符合要求的两个数。

一次字典操作复杂度是 O(logn)，6行做n次，12行做m次，总复杂度 O(nlogn + mlogn)，能通过 100% 的测试。

n,m,x=map(int,input().split())
a=[0]+list(map(int,input().split()))    #加a[0],从a[1]开始
pos=[0]*(n+10)
pos[n+1]=1<<30
mp={}           #定义字典，字典能把数与位置联系起来
for i in range(n,0,-1):     #n次
    mp[a[i]]=i              #把a[i]映射到i
    y=x^a[i]                #若a^b=c,则b=a^c
    pos[i]=pos[i+1]         #从下一个位置找符合条件的数
    if mp.get(y):
        pos[i]=min(pos[i],mp[y])   #最近位置
for i in range(m):          #m次
    L,R=map(int,input().split())
    if pos[L]<=R:
        print('yes')
    else:
        print('no')

（3）线段树（100%）

区间问题一般用线段树，但是本题的区间查询是任意两个数的异或。

如果能建模为区间最值或区间和，线段树就有效了。

• 题目是找区间内的 ai⊕aj=x，其中 x 是给定的常数。
• 变形为对区间内的每个 ai，在区间内找一个 aj=ai⊕x。
• 对于 ai 来说，可能有多个 aj 满足，显然那个距离它最近的 aj 最好，这样在做任意区间查询的时候，最小的区间查询也能满足。

定义一个数组 Left[]，Left[i] 表示 a[i] 左边最近的等于 ai⊕x 的数 aj 的位置。

本题转换为在区间 [L, R] 内查询一个大于 L 的 Left[i]，a[i]的i显然小于R，此时满足题目要求的一对数是 a[i] 和 a[Left[i]]。

由于那个最大的 Left[i] 肯定满足要求，这样就转换成了查询区间最值问题。

• 定义 Left[] 时只考虑了 a[i] 左边的数，没有考虑 a[i] 右边的数。这并不会遗漏，因为 a[i] 和它左边的 a[j] 是成对的，对于 a[j] 来说，a[i] 就是右边的数。
• 如何快速计算 Left[]? 这里利用一个哈希技巧，定义数组pos[]，从左到右遍历 a[] 时，用 pos[k] 记录数字 k 上一次出现的位置，那么 Left[i]=pos[ai⊕x]。
• 建模为查询区间最值问题后，用线段树编码。每次查询的复杂度为 O(logn)，m 次查询的总复杂度为 O(mlogn)，能通过 100% 的测试。

N=100010
Left=[0]*N
pos=[0]*((1<<20)+10)
tree=[0]*(N<<2)         #4倍
def bulid(p,pl,pr):
    if pl==pr:
        tree[p]=Left[pl]
        return
    mid=(pl+pr)>>1
    bulid(p<<1,pl,mid)  #p<<1是左儿子
    bulid(p<<1|1,mid+1,pr)  #p<<1|1是右儿子
    tree[p]=max(tree[p<<1],tree[p<<1|1])    #push_up
def query(p,pl,pr,L,R):
    if L<=pl and pr<=R:
        return tree[p]
    mid=(pl+pr)>>1
    res=0
    if L<=mid:
        res=max(res,query(p<<1,pl,mid,L,R))
    if R>mid:
        res=max(res,query(p<<1|1,mid+1,pr,L,R))
    return res
n,m,x=map(int,input().split())
a=list(input().split())
a.insert(0,0)           #加一个a[0],从a[1]开始
for i in range(1,n+1):
    a[i]=int(a[i])
    Left[i]=pos[a[i]^x]
    pos[a[i]]=i
bulid(1,1,n)
for i in range(m):
    L,R=map(int,input().split())
    if query(1,1,n,L,R)>=L:
        print('yes')
    else:
        print('no')