线段树介绍及线段树的使用场景

1.线段树用来解决什么问题

假如说你有一个数组，数组下标为 0-1000，然后对外提供一些方法，

1.1比如说你对外提供add方法，add方法（1,200,6），请你把从1 到 200 位置所有的值加上6

1.2更新（update），传递一个范围，比如（7,375，4） 7-375范围所有值变为4

1.3 query 比如（3,999）查询3到999所有数据的和是多少。

如果暴力方法我们怎么来做啊，add方法遍历嘛，遍历1-200 每个加一个6，更新和query也一样。

所以说线段树用来解决什么问题，区间上统一增加，区间上统一修改，区间上统一查询累加和。而且还能很快。假如说数组一共N个数，线段树做上述操作，能够达到logN级别。

关于线段树的实现，有非递归方法，但是实现起来非常麻烦，本篇文章提供的是递归方法。那么有同学就担心了，那我在工程上使用会不会出问题啊，这里告诉大家，不会的，为啥呢，因为啊，对于线段树这种结构，哪怕你的 N 是 2的64次方，这个线段树最多往下多少层呢，也就64层，也就是说你虽然写了一个递归函数，但是这个递归函数的深度不会太大的。除非你是给神仙写代码，数据量都超过2的64次方了。那确实有可能出错吧。

一般来说，我们线段树数组的下表都是从 1 开始的。如下图

我们想做到这样一个树状结构的感觉，啥意思呢，就是整个范围，最大的格子兜着，然后它会将自己的范围，几乎一般的分给左右两侧，上述例子中，左孩子负责 1到2 右孩子负责 3-4 ，再把这个范围往下分，就如上图的叶子节点。当然实际实现的时候，是用数组实现的。

假设我有一个足够长的数组，0位置我们弃而不用。

是不是有点像堆的感觉。当然有一些公式同样适用，例如任何一个节点 i 的父节点为 i/2，同样到底任何一节点i的左孩子为 2*i 位置;右孩子为 2 * i + 1 位置。这样就有一个问题了，数组我到底要准备多长，这里说一个结论，就是如果原数组长度为N的话，用来存储数结构的数组准备4N绝对够用。

2.懒更新。

我们先说在一个范围上共同累加一个数字 V。

我们假设一个格子表示 1 - 1000 范围上的累加和是多少，然后请你把 3 - 874 上所有的值加上 5。这个格子左侧范围是多少呢？没错，是 1 - 500，右侧范围呢是 501 - 1000;你就知道，这个任务，既应该发给左孩子，右应该发给右孩子。为什么既要发给左孩子，又要发给右孩子呢，因为我这个任务没办法单独被左孩子搞定或者单独被右孩子搞定。这里我们先看左边，我们的左孩子就得到这个任务了，它的左孩子是谁，1 - 250，右孩子呢 251 - 500，总任务是啥 3 - 874，然后我们就知道，这个任务既要发给左，又要发给右，但问题是，我发给右侧之后，这个任务是在整个范围中全得做的。此时，右侧我就缓住不发了。这里我们可以再申请一个一样长的数组，用于存放懒更新的信息。我们就在新申请的数组中表示 251 - 500 位置的值设置为 5，表示拦住该信息。它左边应不应该往下发，应该往下发，为啥，你的任务是 3 - 874 ，而你的范围是 1 - 250 ，没办法完全拦住，所以需要往下发，每次来新任务前，需要把旧的任务往下发一层。例如

假如说我来了一个任务，需要在 1 - 4 位置加一个 3 ，我们就把下面 1 位置更新为3，然后又来一个任务，我需要把 1 - 2 位置加一个 4 ，任务来之后，我们需要先检查是否有懒任务，有的话就往下发一层，我先检查 1-4 有没有，发现有，这样的话往下发一层， 2 ，3 位置就都是 3，然后我1位置就能处理了。我发现任务为 1- 2 位置加一个 4 只用发给左边，然后就往左边发，发时先检查有没有懒任务，发现有，就继续往下发一层，然后把2位置更新为四。所以，最后的数组应该是这样的 [X,0,4,3,3,3,0,0]

Code:

public class SegmentTree {public static class SegmentTree {// arr[]为原序列的信息从0开始，但在arr里是从1开始的// sum[]模拟线段树维护区间和// lazy[]为累加和懒惰标记// change[]为更新的值// update[]为更新慵懒标记private int MAXN;private int[] arr;private int[] sum;private int[] lazy;private int[] change;private boolean[] update;public SegmentTree(int[] origin) {MAXN = origin.length + 1;arr = new int[MAXN]; // arr[0] 不用 从1开始使用for (int i = 1; i < MAXN; i++) {arr[i] = origin[i - 1];}sum = new int[MAXN << 2]; // 用来支持脑补概念中，某一个范围的累加和信息lazy = new int[MAXN << 2]; // 用来支持脑补概念中，某一个范围沒有往下傳遞的纍加任務change = new int[MAXN << 2]; // 用来支持脑补概念中，某一个范围有没有更新操作的任务update = new boolean[MAXN << 2]; // 用来支持脑补概念中，某一个范围更新任务，更新成了什么}private void pushUp(int rt) {sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];}// 之前的，所有懒增加，和懒更新，从父范围，发给左右两个子范围// 分发策略是什么// ln表示左子树元素结点个数，rn表示右子树结点个数private void pushDown(int rt, int ln, int rn) {if (update[rt]) {update[rt << 1] = true;update[rt << 1 | 1] = true;change[rt << 1] = change[rt];change[rt << 1 | 1] = change[rt];lazy[rt << 1] = 0;lazy[rt << 1 | 1] = 0;sum[rt << 1] = change[rt] * ln;sum[rt << 1 | 1] = change[rt] * rn;update[rt] = false;}if (lazy[rt] != 0) {lazy[rt << 1] += lazy[rt];sum[rt << 1] += lazy[rt] * ln;lazy[rt << 1 | 1] += lazy[rt];sum[rt << 1 | 1] += lazy[rt] * rn;lazy[rt] = 0;}}// 在初始化阶段，先把sum数组，填好// 在arr[l~r]范围上，去build，1~N，// rt : 这个范围在sum中的下标public void build(int l, int r, int rt) {if (l == r) {sum[rt] = arr[l];return;}int mid = (l + r) >> 1;build(l, mid, rt << 1);build(mid + 1, r, rt << 1 | 1);pushUp(rt);}// L~R  所有的值变成C// l~r  rtpublic void update(int L, int R, int C, int l, int r, int rt) {if (L <= l && r <= R) {update[rt] = true;change[rt] = C;sum[rt] = C * (r - l + 1);lazy[rt] = 0;return;}// 当前任务躲不掉，无法懒更新，要往下发int mid = (l + r) >> 1;pushDown(rt, mid - l + 1, r - mid);if (L <= mid) {update(L, R, C, l, mid, rt << 1);}if (R > mid) {update(L, R, C, mid + 1, r, rt << 1 | 1);}pushUp(rt);}// L~R, C 任务！// rt，l~rpublic void add(int L, int R, int C, int l, int r, int rt) {// 任务如果把此时的范围全包了！if (L <= l && r <= R) {sum[rt] += C * (r - l + 1);lazy[rt] += C;return;}// 任务没有把你全包！// l  r  mid = (l+r)/2int mid = (l + r) >> 1;pushDown(rt, mid - l + 1, r - mid);// L~Rif (L <= mid) {add(L, R, C, l, mid, rt << 1);}if (R > mid) {add(L, R, C, mid + 1, r, rt << 1 | 1);}pushUp(rt);}// 1~6 累加和是多少？ 1~8 rtpublic long query(int L, int R, int l, int r, int rt) {if (L <= l && r <= R) {return sum[rt];}int mid = (l + r) >> 1;pushDown(rt, mid - l + 1, r - mid);long ans = 0;if (L <= mid) {ans += query(L, R, l, mid, rt << 1);}if (R > mid) {ans += query(L, R, mid + 1, r, rt << 1 | 1);}return ans;}}public static class Right {public int[] arr;public Right(int[] origin) {arr = new int[origin.length + 1];for (int i = 0; i < origin.length; i++) {arr[i + 1] = origin[i];}}public void update(int L, int R, int C) {for (int i = L; i <= R; i++) {arr[i] = C;}}public void add(int L, int R, int C) {for (int i = L; i <= R; i++) {arr[i] += C;}}public long query(int L, int R) {long ans = 0;for (int i = L; i <= R; i++) {ans += arr[i];}return ans;}}public static int[] genarateRandomArray(int len, int max) {int size = (int) (Math.random() * len) + 1;int[] origin = new int[size];for (int i = 0; i < size; i++) {origin[i] = (int) (Math.random() * max) - (int) (Math.random() * max);}return origin;}public static boolean test() {int len = 100;int max = 1000;int testTimes = 5000;int addOrUpdateTimes = 1000;int queryTimes = 500;for (int i = 0; i < testTimes; i++) {int[] origin = genarateRandomArray(len, max);SegmentTree seg = new SegmentTree(origin);int S = 1;int N = origin.length;int root = 1;seg.build(S, N, root);Right rig = new Right(origin);for (int j = 0; j < addOrUpdateTimes; j++) {int num1 = (int) (Math.random() * N) + 1;int num2 = (int) (Math.random() * N) + 1;int L = Math.min(num1, num2);int R = Math.max(num1, num2);int C = (int) (Math.random() * max) - (int) (Math.random() * max);if (Math.random() < 0.5) {seg.add(L, R, C, S, N, root);rig.add(L, R, C);} else {seg.update(L, R, C, S, N, root);rig.update(L, R, C);}}for (int k = 0; k < queryTimes; k++) {int num1 = (int) (Math.random() * N) + 1;int num2 = (int) (Math.random() * N) + 1;int L = Math.min(num1, num2);int R = Math.max(num1, num2);long ans1 = seg.query(L, R, S, N, root);long ans2 = rig.query(L, R);if (ans1 != ans2) {return false;}}}return true;}public static void main(String[] args) {int[] origin = { 2, 1, 1, 2, 3, 4, 5 };SegmentTree seg = new SegmentTree(origin);int S = 1; // 整个区间的开始位置，规定从1开始，不从0开始 -> 固定int N = origin.length; // 整个区间的结束位置，规定能到N，不是N-1 -> 固定int root = 1; // 整棵树的头节点位置，规定是1，不是0 -> 固定int L = 2; // 操作区间的开始位置 -> 可变int R = 5; // 操作区间的结束位置 -> 可变int C = 4; // 要加的数字或者要更新的数字 -> 可变// 区间生成，必须在[S,N]整个范围上buildseg.build(S, N, root);// 区间修改，可以改变L、R和C的值，其他值不可改变seg.add(L, R, C, S, N, root);// 区间更新，可以改变L、R和C的值，其他值不可改变seg.update(L, R, C, S, N, root);// 区间查询，可以改变L和R的值，其他值不可改变long sum = seg.query(L, R, S, N, root);System.out.println(sum);System.out.println("对数器测试开始...");System.out.println("测试结果 : " + (test() ? "通过" : "未通过"));}}

update:

同样我们准备一个update数组，如果我要在 1 - 500 所有范围内变成 7 ，就在update数组中，代表 1 - 500 位置设置值为7。那为啥还要有一个 bool 的数组的，因为如果是 0 的话，你不知道是表示没有update信息呢，还是要全部变为 0 呢。其他过程和add差不多。相信大家看代码很容易就能够看明白。这里面着重说一下pushDown方法为啥更新在前累加在后，因为我们更新操作是会把累加给清空的，如果更新数组和累加数组都有值，说明我们的更新操作是在累加之前。所以我们要先执行更新操作。

3.积方块问题

说，在一个X轴上，会落下一个方块，该方块由两个数组成;例如（1,4）代表左边为X坐标为 1，宽和高都是4的一个方块落下，如下图：

问当落下一个方块后，最高为多少？

这道题就涉及到线段树的改动了。当一个方块落下之后，再有一个方块落下，我们需要将第二个方块的范围的Max，并把该范围所有值更新为Max，然后再共同加上这个高。比如我这个方块宽度坐标为6-10,这里我们需要把6-10的最大值查询出来，并把6-10的值全部更新为最大值加上高度这个值。这里我们要的不是累加和，而是max ，这里就需要更改我们的线段树了。

public class FallingSquares {public static class SegmentTree {private int[] max;private int[] change;private boolean[] update;public SegmentTree(int size) {int N = size + 1;max = new int[N << 2];change = new int[N << 2];update = new boolean[N << 2];}private void pushUp(int rt) {max[rt] = Math.max(max[rt << 1], max[rt << 1 | 1]);}// ln表示左子树元素结点个数，rn表示右子树结点个数private void pushDown(int rt, int ln, int rn) {if (update[rt]) {update[rt << 1] = true;update[rt << 1 | 1] = true;change[rt << 1] = change[rt];change[rt << 1 | 1] = change[rt];max[rt << 1] = change[rt];max[rt << 1 | 1] = change[rt];update[rt] = false;}}public void update(int L, int R, int C, int l, int r, int rt) {if (L <= l && r <= R) {update[rt] = true;change[rt] = C;max[rt] = C;return;}int mid = (l + r) >> 1;pushDown(rt, mid - l + 1, r - mid);if (L <= mid) {update(L, R, C, l, mid, rt << 1);}if (R > mid) {update(L, R, C, mid + 1, r, rt << 1 | 1);}pushUp(rt);}public int query(int L, int R, int l, int r, int rt) {if (L <= l && r <= R) {return max[rt];}int mid = (l + r) >> 1;pushDown(rt, mid - l + 1, r - mid);int left = 0;int right = 0;if (L <= mid) {left = query(L, R, l, mid, rt << 1);}if (R > mid) {right = query(L, R, mid + 1, r, rt << 1 | 1);}return Math.max(left, right);}}public HashMap<Integer, Integer> index(int[][] positions) {TreeSet<Integer> pos = new TreeSet<>();for (int[] arr : positions) {pos.add(arr[0]);pos.add(arr[0] + arr[1] - 1);}HashMap<Integer, Integer> map = new HashMap<>();int count = 0;for (Integer index : pos) {map.put(index, ++count);}return map;}public List<Integer> fallingSquares(int[][] positions) {HashMap<Integer, Integer> map = index(positions);int N = map.size();SegmentTree segmentTree = new SegmentTree(N);int max = 0;List<Integer> res = new ArrayList<>();// 每落一个正方形，收集一下，所有东西组成的图像，最高高度是什么for (int[] arr : positions) {int L = map.get(arr[0]);int R = map.get(arr[0] + arr[1] - 1);int height = segmentTree.query(L, R, 1, N, 1) + arr[1];max = Math.max(max, height);res.add(max);segmentTree.update(L, R, height, 1, N, 1);}return res;}}