算法拾遗三十四线段树
- 线段树说明
- 物理结构使用
- 线段树落方块的问题
线段树说明
给定固定长度的数组，然后要在数组给定的范围内完成加法【如数组1，200下标元素加6】，更新【7，375范围数组元素更新为4】，查询操作【查询3到999范围内数组元素的合】
线段树可以让如上操作变成（logN的时间复杂度）
线段树过程：
1、有如上数组，以及对应的线段树图，在其叶子节点上放置【1-1范围上的和，2-2范围上的和，3-3范围上的和，4-4范围上的和】
2、再叶子节点上面，则记录1-2范围和3-4范围上的和
3、根节点记录1-4范围上的和
对于5个数的情况可以按照如下方式划分：
然后尝试让这个线段树表示成数组的形式：
将格子的内容按照之前线段树构造的方式依次存入：
其中8号位置代表d的左孩子，9号位置代表d的右孩子，他们的左孩子及右孩子都没有关联值的信息，所以不用它们。一直到14（g的左孩子），15（g的右孩子）位置。任何一个节点i它的父节点为i/2，它的左孩子为2乘以i，右孩子为2乘以i加1。当正好是
2的n次方的时候是最省空间的【基本上小于等于2N就够用】，如果是2的某次方加1的时候是最费空间的需要小于等于4N的空间
物理结构使用
各个位置都可以通过左孩子加右孩子算出来
懒更新：
给定范围将范围内的数字加某个特定的值，假设给定范围1-1000，需要在3-874范围内的数字都加5，则需要把任务分给左孩子以及右孩子。
左孩子得到任务再找它的左右孩子。
如上图发现251-500的范围是被整个3-874范围给全部包裹的，那么则可以通过懒更新去记录它，让任务不再往下发送了则新开一个数组在251-500这个范围表示的index标记为5。
如上图1-250范围的任务继续往下下发：
1-125没有被3-874范围全部包裹，126-250被3-874全部包裹了，则可继续使用懒更新。直到全部完成。当有新任务来的时候，则需要将新任务往下发一层再执行新的任务【相当于将当前的懒信息给分解掉了，然后在新的范围内记录新的懒信息】
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) {
//计算节点i需要知道它的左孩子及右孩子 rt << 1 | 1 表示rt*2+1
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
// 之前的，所有懒增加，和懒更新，从父范围，发给左右两个子范围
// 分发策略是什么
// ln表示左子树元素结点个数，rn表示右子树结点个数
//之所以是两个if是有更新在前累加在后的情况，则需要先发更新任务再发累加任务
private void pushDown(int rt, int ln, int rn) {
//父节点有更新信息
if (update[rt]) {
//左右两个孩子都改成true
update[rt << 1] = true;
update[rt << 1 | 1] = true;
//左右两个孩子都记录change
change[rt << 1] = change[rt];
change[rt << 1 | 1] = change[rt];
//左右两孩子的lazy都更新为0
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) {
//rt位置已经被懒了，发一层懒信息
//rt位置的左孩子记录当前位置的懒信息
lazy[rt << 1] += lazy[rt];
//rt位置左孩子的累加和记录
sum[rt << 1] += lazy[rt] * ln;
//rt位置的右孩子记录当前位置的懒信息
lazy[rt << 1 | 1] += lazy[rt];
//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 rt
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;
//累加和是重新设置
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 所有的加上C 表示任务
// rt，l~r 【当前来到rt位置，rt能表示的范围在[l,r]上】
public void add(int L, int R, int C, int l, int r, int rt) {
// 任务如果把此时的范围全包了！
if (L <= l && r <= R) {
//累加和[l,r]范围都加C
sum[rt] += C * (r - l + 1);
//记录懒更新
lazy[rt] += C;
//直接return，任务全被包了
return;
}
// 任务没有把你全包！求出中点，发一层懒任务
// l r mid = (l+r)/2
int mid = (l + r) >> 1;
//老任务发掉了
pushDown(rt, mid - l + 1, r - mid);
// L~R
if (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 rt
public 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]整个范围上build
seg.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() ? "通过" : "未通过"));
}
}
线段树落方块的问题
掉落的方块
//题目链接 https://leetcode.cn/problems/falling-squares/
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;
}
}
下面谈一下具体改动，首先sum数组，在这道题里是max数组。
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];
}
........
}
然后，求max，和求累加和，肯定是不一样的，所以修改 pushUp方法
private void pushUp(int rt) {
max[rt] = Math.max(max[rt << 1], max[rt << 1 | 1]);
}
当一个范围内所有数字都改变的时候，累加和是：个数 * 改成的数字，而最大值是：改成的数字，所以修改 pushDown方法
// 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;
}
}
然后，update任务的时候，累加和的逻辑和max的逻辑依然不一样，修改 update方法：
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);
}
然后，查询的时候，累加和 = 左部分累加和 + 右部分累加和，最大值 = Math.max (左部分最大值，右部分最大值)，所以修改 query方法：
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);
}
最后！很关键的一步，叫线段树的离散化，这是什么意思？我们举个例子：
比如：
线段A的左边界、右边界为[ 3, 100万]；
线段B的左边界、右边界为[ 4000, 10亿]；
线段C的左边界、右边界为[ 500万, 7000万]；
假设就这么三个线段，如果不做任何优化，因为最大的边界值是10亿，所以你的线段树要支持到10亿，但是这太浪费空间了！
于是我们把所有的边界值排个序，如下：
原始值：3 4000 100万 500万 7000万 10亿
排名值：1 2 3 4 5 6
于是，我们可以认为所有的线段如下：
线段A的左边界、右边界为[ 1, 3]；
线段B的左边界、右边界为[ 2, 6]；
线段C的左边界、右边界为[ 4, 5]；
也就是把原始值，替换成排名值。
所有的线段、所有的左右边界都参与了排名！那么没有出现的数字，本来也用不到！对不对！
这样一来，线段树的空间可以大量节省！原来需要支持到10亿，现在只需要支持到6即可！
这部分的内容就是代码中的这一块：
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);
在fallingSquares方法中，有一个map，是利用index(positions)得到的。这是在做什么？
就是把所有线段原始的左右边界，变成排名值。
这个map的key就是原始值，value就是对应的排名值
比如刚才的例子：
线段A的左边界、右边界为[ 3, 100万]；
线段B的左边界、右边界为[ 4000, 10亿]；
线段C的左边界、右边界为[ 500万, 7000万]；
那么在map里，如下：
key value
3 1
100万 3
4000 2
10亿 6
500万 4
7000万 5
也就是说，线段的原始值，通过map查询一下，就是排名值。
线段树只需要支持排名值就可以了！
有几个排名，线段树就支持多大，所以：
HashMap<Integer, Integer> map = index(positions);
int N = map.size();
SegmentTree segmentTree = new SegmentTree(N);
后面就是线段树的查询了。
扩展：
一条线上有很多个房子，存在一个update方法可以将L，R范围内的房子刷为统一的颜色，存在一个query方法可以求得L，R范围上面有多少种颜色，一共有56种颜色。
可以用一个long的位信息来表示颜色是否出现，通过左边的颜色或上右边的颜色信息就能知道L-R范围上有多少种颜色了。
线段树的适用范围不是无限宽的,线段树只能适用于我有左边的信息以及右边的信息，父节点的信息可以由左右两边的信息通过O（1）来得到，并且我不用调研底层具体状况，只用简单加工得来【区间查询，区间更新，区间增加】的问题能用线段树
