秋招算法总结：线段树_树状数组_原理_区别_代码实现

0 线段树与树状数组的区别

1. 线段树和树状数组都需要满足区间的结合律和可加性：
   • 比如加法，乘法，最大值，最小值
2. 树状数组只能维护前缀“操作和”(前缀和，前缀积，前缀最大最小)，而线段树可以维护区间操作和
3. 树状数组的区间操作是利用两个前缀和操作抵消的（操作存在逆元的情况下）
   • 维护区间和，模质数意义下的区间乘积，区间 xor 和。能这样做的本质是取右端点的前缀结果，然后对左端点左边的前缀结果的逆元做一次操作，所以树状数组的区间询问其实是在两次前缀和询问
   • 但维护不了另一些的:最大/最小值，模非质数意义下的乘法，原因在于这些操作不存在逆元，所以就没法用两个前缀和做。

1 树状数组

1.1 核心思想

⁉️如何基于编号，构件一个不重叠的子序列集合。

假如需要求前13个元素的前缀和 $num=13=1101_2$：

首先处理 $bit=1$ 这一位，其代表的范围是：
$$[1100_2+0001_2,1100_2+0001_2]$$
然后在num上减去他：$num-=(1<<(bit-1))=1100_2$

然后，我们处理 $bit=3$这一位：其代表的范围是：
$$[1000_2+0001_2,1000_2+0100_2]$$
同样，我们在num上减去它

最后我们处理 $bit=4$ 这一位：其代表的范围是：
$$[0000_2+0001_2,0000_2+1000_2]$$
我们回顾整个处理流程，可以惊讶的发现，❤️如果我们按照逆序处理，我们每次处理的bit都是当前编号的最后的为1位。
$$[cur-lowbit(cur)+1,cur]$$
我们将每次处理的bit定义为 lowbit, lowbit(i)即i这个数的最低位是第几位（从右数从1开始）

$tree[i]$ 控制
$$[i-lowbit(i)+1,i]$$
范围内的f[i]

总结

树状数组，将对前 $n$ 个元素求和分为了 $lo{g}_{2}n$ 个不重叠的部分，下图中格内数字代表 $tree[i]$

1.2 流程伪码

求和

 T tree[maxn];
template 
T query(int i){
	T res = 0;
    while (i > 0){
        res += tree[i];
        i -= lowbit(i);
    }
    return res;
}

更新

int n; // BIT 的大小， BIT index 从 1 开始
T tree[maxn];
template 
void add(int i, T x){
    while (i <= n){
        tree[i] += x;
        i += lowbit(i);
    }
}

lowbit运算
$$lowbit(x)=(x\&(-x))$$
建树

for (i = 1; i <= n; ++i){
    scanf("%d", arr + i), update(i, arr[i], c, n);
}

注意

BIT是从下标1开始存储的

1.3 例题

307. 区域和检索 - 数组可修改 - 力扣（LeetCode）

2 线段树

2.1 原理

❓二叉搜索树如何编号

二叉搜索树的根节点编号为1，对于每个节点，假如其编号为N，它的左儿子编号为2N，右儿子编号为2N+1。因此，整个二叉搜索树的编号如下

线段树本质也是一个❤️二叉搜索树，区别在于线段树的❤️每一个节点记录的都是一个区间，每个区间都被平均分为2个子区间，作为它的左右儿子。比如说区间[1，10]，被分为区间[1，5]作为左儿子，区间[6，10]作为右儿子。❤️当一个区间的左右边界已经相等时，比如[1，1]，表示这个区间内只有一个元素了，此时不能再分割，因此它就没有左右儿子节点了

⁉️节点代表区间的范围与节点编号关系

节点 $p$ 储存区间 $[l,r]$ 的和，设
$$mid=\lfloor \frac{l+r}{2}\rfloor$$
左子树 $2p$ 存储区间为 $[l,mid]$ , 右子树 $2p+1$ 存储区间为 $[mid+1,r]$

左节点对应的区间长度，与右节点相同或者比之恰好多1。

⁉️区间修改的懒标记

❤️任何区间都是线段树上某些节点的并集，要修改的区间与当前区间存在三种关系：

1. 要修改区间与当前区间相交为空集

   

2. 要修改的区间被当前区间拆开

   

3. 要修改的区间包含在当前区间的左孩子或右孩子内

   

懒惰标记的初衷就是延迟修改，❤️找到目标区间后直接在相应节点打上懒标记，不需要再向下递归

现在假如我们需要把区间[5，7]每个元素增加2：

注意

找到目标区间后要做两件事：

1. ❤️更新当前节点代表区间的区间和
2. 打上懒标记

区间和增加的值要乘区间长度，但懒惰标记的值不用乘，所以懒标记其实是

❤️延迟下放+只下放一层

⁉️pushdown函数

下传懒惰标记步骤有3步：

1. 将懒惰标记传递给儿子
2. 更新儿子的值
3. 清空当前节点的懒惰标记
4. 叶子节点不用下传懒惰标记

这个过程并不是递归的，我们只往下传递一层，以后要用再才继续传递。

2.2 指针实现

线段树建立

2.3 数组实现

线段树建立

// 参数：当前操作左区间，当前操作右区间，当前操作树的节点编号
void build(ll l = 1, ll r = n, ll p = 1)
{
    if (l == r) // 到达叶子节点
        tree[p] = A[l]; // 用数组中的数据赋值
    	//到达叶子节点时，左右区间相等，等于要新建的数在原始数组中的下标
    else
    {
        ll mid = (l + r) / 2;
        build(l, mid, p * 2); // 先建立左子树
        build(mid + 1, r, p * 2 + 1);// 建立右子树
        tree[p] = tree[p * 2] + tree[p * 2 + 1]; // 该节点的值等于左右子节点之和
    }
}

也可以把参数中当前操作区间的区间端点信息、和存储到struct Node里，就不用以参数传递了

区间修改

void modifySegment(int l, int r, int value, int num) { // [l,r]每一项都增加value
    if (tree[num].l == l && tree[num].r == r) { // 找到当前区间
        tree[num].sum += ( r - l + 1 ) * value; // r-l+1是区间元素个数
        tree[num].lazy += value;
        return;
    }
    int mid = (tree[num].l + tree[num].r) / 2;
    if (r <= mid) { // 在左区间
        modifySegment(l, r, value, num * 2);
    }
    else if (l > mid) { // 在右区间
        modifySegment(l, r, value, num * 2 + 1);
    }
    else { // 分成2块
        modifySegment(l, mid, value, num * 2);
        modifySegment(mid + 1, r, value, num * 2 + 1);
    }
    tree[num].sum = tree[num * 2].sum + tree[num * 2 + 1].sum;
}

区间查询

pushdown函数

void pushdown (int num) {
    if(tree[num].l == tree[num].r) { // 叶节点不用下传标记
        tree[num].lazy = 0; // 清空当前标记
        return;
    }
    
    tree[num * 2].lazy += tree[num].lazy; // 下传左儿子的懒惰标记
    tree[num * 2 + 1].lazy += tree[num].lazy; // 下传右儿子的懒惰标记
    
    tree[num * 2].sum += (tree[num * 2].r - tree[num * 2].l + 1) * tree[num].lazy; // 更新左儿子的值
    tree[num * 2 + 1].sum += (tree[num * 2 + 1].r - tree[num * 2 + 1].l + 1) * tree[num].lazy; // 更新右儿子的值
    
    tree[num].lazy=0; // 清空当前节点的懒惰标记
}

查询

int query (int l, int r, int num) {
    if (tree[num].lazy != 0) { // 下传懒惰标记
        pushdown(num);
    }
    if (tree[num].l == l && tree[num].r == r) { // 找到当前区间
        return tree[num].sum;
    }
    int mid = (tree[num].l + tree[num].r) / 2;
    if (r <= mid) { // 在左区间
        return query(l, r, num * 2);
    }
    if (l > mid) { // 在右区间
        return query(l, r, num * 2 + 1);
    }
    return query(l, mid, num * 2) + query(mid + 1, r, num * 2 + 1); // 分成2块
}

2.4 例题

699. 掉落的方块 - 力扣（LeetCode）

引用

树状数组部分总结自：

树状数组（BIT）—— 一篇就够了 - Last_Whisper - 博客园 (cnblogs.com)

算法学习笔记(2) : 树状数组 - 知乎 (zhihu.com)

(31条消息) 树状数组简单易懂的详解_FlushHip的博客-CSDN博客_树状数组

其中树状数组与线段树区别部分的总结图已无法找到源，应该来自力扣某题解

线段树部分总结自：

(31条消息) 什么是 “线段树” ？_程序员小灰的博客-CSDN博客

算法学习笔记(14): 线段树 - 知乎 (zhihu.com)

线段树详解「汇总级别整理 」 - 掉落的方块 - 力扣（LeetCode）

(33条消息) Balanced Lineup（线段树—指针实现）_AC_Arthur的博客-CSDN博客_指针线段树

一部分代码参考自力扣官方题解