Segment Tree

死線斷裂術

建北電資小社課演算法

Segment Tree

線段樹

225班
電子計算機研習社_學術長
綽號807

這我

這建北電資

線段樹

二元樹
節點存區間和
子結點 : 子區間

線段樹

怎麼分區間?

從中間切一半

1

5

8

4

3

7

2

6

13

7

9

19

16

35

若 $n$ 為2的冪次

$n$ 代表資料長度

如果資料長度不是2的冪次

1

5

8

4

3

7

2

1

13

7

9

14

16

30

這樣也行

若 $n$ 非2的冪次

$n$ 代表資料長度

建樹 : $O(n log(n))$ 或 $O(n)$
查詢 : $O(log(n))$
修改 : $O(log(n))$

複雜度

複雜度比較

	線段樹	前綴和	差分
建表
區間查詢
單點修改
區間修改

$O(n \times log(n))$

或 $O(n)$

$O(n)$

$O(log(n))$

$O(1)$

$O(n)$

$O(log(n))$

$O(n)$

$O(1)$

$O(log(n))$

$O(n)$

$O(1)$

存樹

用 struct 存
- 左子節點指標
- 右子節點指標
- 值

指標型存法

struct node{
    int value;
    node *left, *right;
};

開 4 倍大的陣列
以節點 $x$
- 左子節點位置 $x \times 2$
- 右子節點位置 $x \times 2 + 1$

陣列型存法 (偽指標型)

int n;
vector<int> data(n*4,0);

註: $n$ 代表原資料長度

4 倍哪來的

若 $n$ 為2的冪次

註: $n$ 代表原資料長度

最下層有 $n$ 個 (節點)
上層有 $n \div 2$ 個
上上層有 $n \div 2 \div 2$ 個
上上上層有 $n \div 2 \div 2 \div 2$ 個

. . .

若 $n$ 為2的冪次

註: $n$ 代表原資料長度

有 $log_2 n+1$ 層
需要 $\frac{2^{log_2 n+1}-1}{2-1} \approx 2n$ 個 (節點)

若 $n$ 不是 2的冪次

註: $n$ 代表原資料長度

$n$ 到 $2n$ 間有一個 $n$ 的冪次
他需要的空間小於 $2n \times 2 = 4n$
我不會證明，你可以接受就好

開 2 倍大的陣列
以節點 $x$
- 左子節點位置 $x \times 2$
- 右子節點位置 $x \times 2 + 1$

迭代式線段樹陣列型存法

int n;
vector<int> data(n*2,0);

註: $n$ 代表原資料長度

2 倍哪來的

有點複雜等等再說

建樹

Create

遞迴將左右子節點計算完
結和左右子節點值 (pull)
遞迴完就結束了

建樹遞迴陣列型

線段樹建樹 code

#include <bits/stdc++.h>
#define int long long
using namespace std;
struct SegmentTree {
	int n;
	vector<int> nodes;
	SegmentTree()
		: n(0) {
		nodes.clear();
	}
	SegmentTree(vector<int> &data)
		: n(data.size()) {
		nodes.resize(n * 4);
		build(data, 0, n);
	}
	void build(const vector<int> &data, int l, int r, int it = 1) {
		if (r - l == 1) {
			nodes[it] = data[l];
			return;
		}
		int mid = (l + r) / 2;
		build(data, l, mid, it * 2);
		build(data, mid, r, it * 2 + 1);
		nodes[it] = nodes[it * 2] + nodes[it * 2 + 1];
		return;
	}
};

# PRESENTING CODE

初始化 nodes 大小

宣告變數

到葉節點複製值進去

取得中間值區分左右子節點的區間

左區間在 $x \times 2$

右區間在 $x \times 2 +1$

遞迴計算子節點值

結合左右子節點值 (pull)

遞迴函式

還沒到葉節點

變數解釋

$n$ 資料長度

$nodes$ 節點值

$data$ 原始資料

$l$ $r$ 左右邊界

$mid$ 中介: 區分左右子區間

$it$ 偽指標: 指向結點在 $nodes$ 的位置

註: 皆為左閉右開 0-base

少於 $4n$ 個節點
每個節點只跑一次
複雜度: $O(n)$

複雜度分析

查詢

Read

遞迴下去做
三種可能
- 完全在左
- 完全在右
- 左右都有

查詢

線段樹查詢 code

#include <bits/stdc++.h>
#define int long long
using namespace std;
struct SegmentTree {
	int n;
	vector<int> nodes;
	SegmentTree()
		: n(0) {
		nodes.clear();
	}
	SegmentTree(vector<int> &data)
		: n(data.size()) {
		nodes.resize(n * 4);
		build(data, 0, n);
	}
	void build(const vector<int> &data, int l, int r, int it = 1) {
		if (r - l == 1) {
			nodes[it] = data[l];
			return;
		}
		int mid = (l + r) / 2;
		build(data, l, mid, it * 2);
		build(data, mid, r, it * 2 + 1);
		nodes[it] = nodes[it * 2] + nodes[it * 2 + 1];
		return;
	}
	int query(int queryL, int queryR, int l, int r, int it = 1) {
		if (queryL == l && queryR == r) return nodes[it];
		int mid = (l + r) / 2;
		if (queryR <= mid)
			return query(queryL, queryR, l, mid, it * 2);
		else if (queryL >= mid)
			return query(queryL, queryR, mid, r, it * 2 + 1);
		else return query(queryL, mid, l, mid,
						  it * 2) +
					query(mid, queryR, mid, r,
						  it * 2 + 1);
	}
};

# PRESENTING CODE

已經找到了

取得中間值區分左右節點範圍

完全在左

完全在右

左右都有

注意範圍

變數解釋

$nodes$ 節點值

$queryL$ $queryR$ 搜尋左右界

$l$ $r$ 左右邊界

$mid$ 中介: 區分左右子區間

$it$ 偽指標: 指向結點在 $nodes$ 的位置

註: 皆為左閉右開 0-base

他是好的
一層最多碰到4的節點
深度 : $log(n)$
複雜度 : $O(log(n))$

複雜度

單點修改

Update

線段樹單點修改 code

#include <bits/stdc++.h>
#define int long long
using namespace std;
struct SegmentTree {
	int n;
	vector<int> nodes;
	SegmentTree()
		: n(0) {
		nodes.clear();
	}
	SegmentTree(vector<int> &data)
		: n(data.size()) {
		nodes.resize(n * 4);
		build(data, 0, n);
	}
	void build(const vector<int> &data, int l, int r, int it = 1) {
		if (r - l == 1) {
			nodes[it] = data[l];
			return;
		}
		int mid = (l + r) / 2;
		build(data, l, mid, it * 2);
		build(data, mid, r, it * 2 + 1);
		nodes[it] = nodes[it * 2] + nodes[it * 2 + 1];
		return;
	}
	int query(int queryL, int queryR, int l, int r, int it = 1) {
		if (queryL == l && queryR == r) return nodes[it];
		int mid = (l + r) / 2;
		if (queryR <= mid)
			return query(queryL, queryR, l, mid, it * 2);
		else if (queryL >= mid)
			return query(queryL, queryR, mid, r, it * 2 + 1);
		else return query(queryL, mid, l, mid,
						  it * 2) +
					query(mid, queryR, mid, r,
						  it * 2 + 1);
	}
	void modify1(int pos, int modifyValue, int l, int r, int it = 1) {
		if (r - l == 1) {
			nodes[it] = modifyValue;
			return;
		}
		int mid = (l + r) / 2;
		if (pos < mid) modify1(pos, modifyValue, l, mid, it * 2);
		else modify1(pos, modifyValue, mid, r, it * 2 + 1);
		// pull
		nodes[it] = nodes[it * 2] + nodes[it * 2 + 1];
		return;
	}
};

# PRESENTING CODE

已經找到了直接修改

取得中間值區分左右節點範圍

在左

在右

修改目前節點值 (pull)

註: 皆為左閉右開 0-base

變數解釋

$nodes$ 節點值

$queryL$ $queryR$ 搜尋左右界

$l$ $r$ 左右邊界

$mid$ 中介: 區分左右子區間

$it$ 偽指標: 指向結點在 $nodes$ 的位置

改值後 pull 上來
複雜度就是最深深度
複雜度 $O(log(n))$

複雜度

多點修改

Update

懶人標記 (tag)
兩種做法
- 懶標下推 (推薦)
- 懶標永久化

懶標

線段樹懶標下推 code

#include <bits/stdc++.h>
#define int long long
using namespace std;
struct SegmentTree {
	int n;
	vector<int> nodes;
	vector<int> tags;
	SegmentTree()
		: n(0) {
		nodes.clear();
		tags.clear();
	}
	SegmentTree(vector<int> &data)
		: n(data.size()) {
		nodes.resize(n * 4);
		tags.resize(n * 4);
		build(data, 0, n);
	}
	void build(const vector<int> &data, int l, int r, int it = 1) {
		if (r - l == 1) {
			nodes[it] = data[l];
			return;
		}
		int mid = (l + r) / 2;
		build(data, l, mid, it * 2);
		build(data, mid, r, it * 2 + 1);
		nodes[it] = nodes[it * 2] + nodes[it * 2 + 1];
		return;
	}
	void push(int l, int r, int it) {
		int mid = (l + r) / 2;
		nodes[it * 2] += tags[it] * (mid - l);
		nodes[it * 2 + 1] += tags[it] * (r - mid);
		tags[it * 2] += tags[it];
		tags[it * 2 + 1] += tags[it];
		tags[it] = 0;
        return;
	}
	int query(int queryL, int queryR, int l, int r, int it = 1) {
		if (queryL == l && queryR == r) return nodes[it];
		push(l, r, it);
		int mid = (l + r) / 2;
		if (queryR <= mid)
			return query(queryL, queryR, l, mid, it * 2);
		else if (queryL >= mid)
			return query(queryL, queryR, mid, r, it * 2 + 1);
		else return query(queryL, mid, l, mid,
						  it * 2) +
					query(mid, queryR, mid, r,
						  it * 2 + 1);
	}
	void modify(int modifyL, int modifyR, int delta,
				int l, int r, int it = 1) {
		if (modifyL == l && modifyR == r) {
			nodes[it] += delta * (r - l);
			tags[it] += delta;
			return;
		}
		push(l, r, it);
		int mid = (l + r) / 2;
		if (modifyR <= mid)
			modify(modifyL, modifyR, delta, l, mid, it * 2);
		else if (modifyL >= mid)
			modify(modifyL, modifyR, delta, mid, r, it * 2 + 1);
		else {
			modify(modifyL, mid, delta, l, mid, it * 2);
			modify(mid, modifyR, delta, mid, r, it * 2 + 1);
		}
		// pull
		nodes[it] = nodes[it * 2] + nodes[it * 2 + 1];
		return;
	}
};

# PRESENTING CODE

新增宣告 tags (懶標)

build 函式不需要改

註: 皆為左閉右開 0-base

變數解釋

$nodes$ 節點值

$tags$ 懶標值

$l$ $r$ 左右邊界

$mid$ 中介: 區分左右子區間

$it$ 偽指標: 指向結點在 $nodes$ 的位置

線段樹懶標下推 code push()

#include <bits/stdc++.h>
#define int long long
using namespace std;
struct SegmentTree {
	int n;
	vector<int> nodes;
	vector<int> tags;
	SegmentTree()
		: n(0) {
		nodes.clear();
		tags.clear();
	}
	SegmentTree(vector<int> &data)
		: n(data.size()) {
		nodes.resize(n * 4);
		tags.resize(n * 4);
		build(data, 0, n);
	}
	void build(const vector<int> &data, int l, int r, int it = 1) {
		if (r - l == 1) {
			nodes[it] = data[l];
			return;
		}
		int mid = (l + r) / 2;
		build(data, l, mid, it * 2);
		build(data, mid, r, it * 2 + 1);
		nodes[it] = nodes[it * 2] + nodes[it * 2 + 1];
		return;
	}
	void push(int l, int r, int it) {
		int mid = (l + r) / 2;
		nodes[it * 2] += tags[it] * (mid - l);
		nodes[it * 2 + 1] += tags[it] * (r - mid);
		tags[it * 2] += tags[it];
		tags[it * 2 + 1] += tags[it];
		tags[it] = 0;
        return;
	}
	int query(int queryL, int queryR, int l, int r, int it = 1) {
		if (queryL == l && queryR == r) return nodes[it];
		push(l, r, it);
		int mid = (l + r) / 2;
		if (queryR <= mid)
			return query(queryL, queryR, l, mid, it * 2);
		else if (queryL >= mid)
			return query(queryL, queryR, mid, r, it * 2 + 1);
		else return query(queryL, mid, l, mid,
						  it * 2) +
					query(mid, queryR, mid, r,
						  it * 2 + 1);
	}
	void modify(int modifyL, int modifyR, int delta,
				int l, int r, int it = 1) {
		if (modifyL == l && modifyR == r) {
			nodes[it] += delta * (r - l);
			tags[it] += delta;
			return;
		}
		push(l, r, it);
		int mid = (l + r) / 2;
		if (modifyR <= mid)
			modify(modifyL, modifyR, delta, l, mid, it * 2);
		else if (modifyL >= mid)
			modify(modifyL, modifyR, delta, mid, r, it * 2 + 1);
		else {
			modify(modifyL, mid, delta, l, mid, it * 2);
			modify(mid, modifyR, delta, mid, r, it * 2 + 1);
		}
		// pull
		nodes[it] = nodes[it * 2] + nodes[it * 2 + 1];
		return;
	}
};

# PRESENTING CODE

需要知道子節點範圍

左右子節點都加上

$懶標 \times 範圍大小$

更新子節點懶標

懶標歸0

push 完成

註: 皆為左閉右開 0-base

變數解釋

$nodes$ 節點值

$tags$ 懶標值

$l$ $r$ 左右邊界

$mid$ 中介: 區分左右子區間

$it$ 偽指標: 指向結點在 $nodes$ 的位置

線段樹懶標下推 code query()

#include <bits/stdc++.h>
#define int long long
using namespace std;
struct SegmentTree {
	int n;
	vector<int> nodes;
	vector<int> tags;
	SegmentTree()
		: n(0) {
		nodes.clear();
		tags.clear();
	}
	SegmentTree(vector<int> &data)
		: n(data.size()) {
		nodes.resize(n * 4);
		tags.resize(n * 4);
		build(data, 0, n);
	}
	void build(const vector<int> &data, int l, int r, int it = 1) {
		if (r - l == 1) {
			nodes[it] = data[l];
			return;
		}
		int mid = (l + r) / 2;
		build(data, l, mid, it * 2);
		build(data, mid, r, it * 2 + 1);
		nodes[it] = nodes[it * 2] + nodes[it * 2 + 1];
		return;
	}
	void push(int l, int r, int it) {
		int mid = (l + r) / 2;
		nodes[it * 2] += tags[it] * (mid - l);
		nodes[it * 2 + 1] += tags[it] * (r - mid);
		tags[it * 2] += tags[it];
		tags[it * 2 + 1] += tags[it];
		tags[it] = 0;
        return;
	}
	int query(int queryL, int queryR, int l, int r, int it = 1) {
		if (queryL == l && queryR == r) return nodes[it];
		push(l, r, it);
		int mid = (l + r) / 2;
		if (queryR <= mid)
			return query(queryL, queryR, l, mid, it * 2);
		else if (queryL >= mid)
			return query(queryL, queryR, mid, r, it * 2 + 1);
		else return query(queryL, mid, l, mid,
						  it * 2) +
					query(mid, queryR, mid, r,
						  it * 2 + 1);
	}
	void modify(int modifyL, int modifyR, int delta,
				int l, int r, int it = 1) {
		if (modifyL == l && modifyR == r) {
			nodes[it] += delta * (r - l);
			tags[it] += delta;
			return;
		}
		push(l, r, it);
		int mid = (l + r) / 2;
		if (modifyR <= mid)
			modify(modifyL, modifyR, delta, l, mid, it * 2);
		else if (modifyL >= mid)
			modify(modifyL, modifyR, delta, mid, r, it * 2 + 1);
		else {
			modify(modifyL, mid, delta, l, mid, it * 2);
			modify(mid, modifyR, delta, mid, r, it * 2 + 1);
		}
		// pull
		nodes[it] = nodes[it * 2] + nodes[it * 2 + 1];
		return;
	}
};

# PRESENTING CODE

每次到了就下推

註: 皆為左閉右開 0-base

變數解釋

$nodes$ 節點值

$queryL$ $queryR$ 搜尋左右界

$l$ $r$ 左右邊界

$mid$ 中介: 區分左右子區間

$it$ 偽指標: 指向結點在 $nodes$ 的位置

線段樹懶標下推 code modify()

#include <bits/stdc++.h>
#define int long long
using namespace std;
struct SegmentTree {
	int n;
	vector<int> nodes;
	vector<int> tags;
	SegmentTree()
		: n(0) {
		nodes.clear();
		tags.clear();
	}
	SegmentTree(vector<int> &data)
		: n(data.size()) {
		nodes.resize(n * 4);
		tags.resize(n * 4);
		build(data, 0, n);
	}
	void build(const vector<int> &data, int l, int r, int it = 1) {
		if (r - l == 1) {
			nodes[it] = data[l];
			return;
		}
		int mid = (l + r) / 2;
		build(data, l, mid, it * 2);
		build(data, mid, r, it * 2 + 1);
		nodes[it] = nodes[it * 2] + nodes[it * 2 + 1];
		return;
	}
	void push(int l, int r, int it) {
		int mid = (l + r) / 2;
		nodes[it * 2] += tags[it] * (mid - l);
		nodes[it * 2 + 1] += tags[it] * (r - mid);
		tags[it * 2] += tags[it];
		tags[it * 2 + 1] += tags[it];
		tags[it] = 0;
        return;
	}
	int query(int queryL, int queryR, int l, int r, int it = 1) {
		if (queryL == l && queryR == r) return nodes[it];
		push(l, r, it);
		int mid = (l + r) / 2;
		if (queryR <= mid)
			return query(queryL, queryR, l, mid, it * 2);
		else if (queryL >= mid)
			return query(queryL, queryR, mid, r, it * 2 + 1);
		else return query(queryL, mid, l, mid,
						  it * 2) +
					query(mid, queryR, mid, r,
						  it * 2 + 1);
	}
	void modify(int modifyL, int modifyR, int delta,
				int l, int r, int it = 1) {
		if (modifyL == l && modifyR == r) {
			nodes[it] += delta * (r - l);
			tags[it] += delta;
			return;
		}
		push(l, r, it);
		int mid = (l + r) / 2;
		if (modifyR <= mid)
			modify(modifyL, modifyR, delta, l, mid, it * 2);
		else if (modifyL >= mid)
			modify(modifyL, modifyR, delta, mid, r, it * 2 + 1);
		else {
			modify(modifyL, mid, delta, l, mid, it * 2);
			modify(mid, modifyR, delta, mid, r, it * 2 + 1);
		}
		// pull
		nodes[it] = nodes[it * 2] + nodes[it * 2 + 1];
		return;
	}
};

# PRESENTING CODE

如果範圍正確

更新此節點值

加上懶標

有點像單點修改+區間查詢

下推

完全在左

完全在右

取得中間值

左右都有

修改目前節點值 (pull)

註: 皆為左閉右開 0-base

變數解釋

$nodes$ 節點值

$tags$ 懶標值

$modifyL$ $modifyR$ 修改左右區間

$delta$ 修改增加值

根區間查尋一樣
複雜度 : $O(log(n))$

複雜度

迭代式線段樹

節省一半記憶體
常數小
$O(n)$ 建樹 $\leftrightarrow$ 遞迴式線段樹
有點懸的存圖
code 短

優點

存圖方式 $n$ 為2的冪次

註: $n$ 代表原資料長度

迭代式線段樹存圖 code

#include <bits/stdc++.h>
#define int long long
using namespace std;
struct SegmentTree {
	int n;
	vector<int> nodes;
	SegmentTree()
		: n(0) {
		nodes.clear();
	}
	SegmentTree(vector<int> &data)
		: n(data.size()) {
		nodes.resize(n << 1);
		build(data);
	}
	void build(const vector<int> &data) {
		for (int i = n; i--;) nodes[i + n] = data[i];
		for (int i = n; i--;)
			nodes[i] = nodes[i << 1] + nodes[i << 1 | 1];
		return;
	}
	void pull(int pos) {
		for (pos += n; pos >>= 1;)
			nodes[pos] = nodes[pos << 1] + nodes[pos << 1 | 1];
		return;
	}
	int query(int l, int r) {
		int sum = 0;
		for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
			if (l & 1) sum += nodes[l++];
			if (r & 1) sum += nodes[--r];
		}
		return sum;
	}
	void modify1(int pos, int modifyValue) {
		nodes[pos + n] = modifyValue;
		pull(pos);
		return;
	}
};

# PRESENTING CODE

迭代式線段樹 build code

#include <bits/stdc++.h>
#define int long long
using namespace std;
struct SegmentTree {
	int n;
	vector<int> nodes;
	SegmentTree()
		: n(0) {
		nodes.clear();
	}
	SegmentTree(vector<int> &data)
		: n(data.size()) {
		nodes.resize(n << 1);
		build(data);
	}
	void build(const vector<int> &data) {
		for (int i = n; i--;) nodes[i + n] = data[i];
		for (int i = n; i--;)
			nodes[i] = nodes[i << 1] + nodes[i << 1 | 1];
		return;
	}
	void pull(int pos) {
		for (pos += n; pos >>= 1;)
			nodes[pos] = nodes[pos << 1] + nodes[pos << 1 | 1];
		return;
	}
	int query(int l, int r) {
		int sum = 0;
		for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
			if (l & 1) sum += nodes[l++];
			if (r & 1) sum += nodes[--r];
		}
		return sum;
	}
	void modify1(int pos, int modifyValue) {
		nodes[pos + n] = modifyValue;
		pull(pos);
		return;
	}
};

# PRESENTING CODE

迭代式線段樹 query code

#include <bits/stdc++.h>
#define int long long
using namespace std;
struct SegmentTree {
	int n;
	vector<int> nodes;
	SegmentTree()
		: n(0) {
		nodes.clear();
	}
	SegmentTree(vector<int> &data)
		: n(data.size()) {
		nodes.resize(n << 1);
		build(data);
	}
	void build(const vector<int> &data) {
		for (int i = n; i--;) nodes[i + n] = data[i];
		for (int i = n; i--;)
			nodes[i] = nodes[i << 1] + nodes[i << 1 | 1];
		return;
	}
	void pull(int pos) {
		for (pos += n; pos >>= 1;)
			nodes[pos] = nodes[pos << 1] + nodes[pos << 1 | 1];
		return;
	}
	int query(int l, int r) {
		int sum = 0;
		for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
			if (l & 1) sum += nodes[l++];
			if (r & 1) sum += nodes[--r];
		}
		return sum;
	}
	void modify1(int pos, int modifyValue) {
		nodes[pos + n] = modifyValue;
		pull(pos);
		return;
	}
};

# PRESENTING CODE

迭代式線段樹單點修改 code

#include <bits/stdc++.h>
#define int long long
using namespace std;
struct SegmentTree {
	int n;
	vector<int> nodes;
	SegmentTree()
		: n(0) {
		nodes.clear();
	}
	SegmentTree(vector<int> &data)
		: n(data.size()) {
		nodes.resize(n << 1);
		build(data);
	}
	void build(const vector<int> &data) {
		for (int i = n; i--;) nodes[i + n] = data[i];
		for (int i = n; i--;)
			nodes[i] = nodes[i << 1] + nodes[i << 1 | 1];
		return;
	}
	void pull(int pos) {
		for (pos += n; pos >>= 1;)
			nodes[pos] = nodes[pos << 1] + nodes[pos << 1 | 1];
		return;
	}
	int query(int l, int r) {
		int sum = 0;
		for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
			if (l & 1) sum += nodes[l++];
			if (r & 1) sum += nodes[--r];
		}
		return sum;
	}
	void modify1(int pos, int modifyValue) {
		nodes[pos + n] = modifyValue;
		pull(pos);
		return;
	}
};

# PRESENTING CODE

一樣要懶標

多點修改

迭代式線段樹 code 懶標

#include <bits/stdc++.h>
#define int long long
using namespace std;
struct SegmentTree {
	int n;
	vector<int> nodes;
	vector<int> tags;
	SegmentTree()
		: n(0) {
		nodes.clear();
		tags.clear();
	}
	SegmentTree(vector<int> &data)
		: n(data.size()) {
		nodes.resize(n << 1, 0);
		tags.resize(n, 0);
		build(data);
	}
	void build(const vector<int> &data) {
		for (int i = n; i--;) nodes[i + n] = data[i];
		for (int i = n; i--;)
			nodes[i] = nodes[i << 1] + nodes[i << 1 | 1];
		return;
	}
	void pull(int pos) {
		pos += n;
		for (int h = 1; pos >>= 1; h++)
			nodes[pos] = nodes[pos << 1] + nodes[pos << 1 | 1] +
						 (tags[pos] << h);
		return;
	}
	void push(int pos) {
		pos += n;
		for (int h = __lg(pos), it = 1; h--; it = pos >> h) {
			if (!tags[it]) continue;
			nodes[it << 1] += tags[it] << h;
			nodes[it << 1 | 1] += tags[it] << h;
			if (h) {
				tags[it << 1] += tags[it];
				tags[it << 1 | 1] += tags[it];
			}
			tags[it] = 0;
		}
	}
	int query(int l, int r) {
		push(l), push(r - 1);
		int sum = 0;
		for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
			if (l & 1) sum += nodes[l++];
			if (r & 1) sum += nodes[--r];
		}
		return sum;
	}
	void modify(int l, int r, int delta) {
		push(l), push(r - 1);
		int l2 = l + n, r2 = r + n;
		if (l2 & 1) nodes[l2++] += delta;
		if (r2 & 1) nodes[--r2] += delta;
		for (int h = 1; (l2 >>= 1) < (r2 >>= 1); h++) {
			if (l2 & 1) tags[l2] += delta, nodes[l2++] += delta << h;
			if (r2 & 1) tags[--r2] += delta, nodes[r2] += delta << h;
		}
		pull(l), pull(r - 1);
	}
};
signed main() {
	int n, q;
	cin >> n >> q;
	vector<int> data(n);
	for (int &i : data) cin >> i;
	SegmentTree st(data);
	for (int mode, l, r, delta; q--;) {
		cin >> mode;
		if (mode == 1) {
			cin >> l >> r >> delta;
			st.modify(l - 1, r, delta);
		}
		else {
			cin >> l;
			cout << st.query(l - 1, l) << "\n";
		}
	}
}

# PRESENTING CODE

指標型線段樹

#include <bits/stdc++.h>
#define int long long
using namespace std;
struct node {
	int l, r;
	int value = 0, tag = 0;
	node *pointerL = nullptr, *pointerR = nullptr;
	node(int _l, int _r)
		: l(_l), r(_r) {}
	node(vector<int> &data) {
		l = 0;
		r = data.size();
		build(data);
	}
	void build(const vector<int> &data) {
		if (r - l == 1) {
			value = data[l];
			return;
		}
		int mid = l + r >> 1;
		pointerL = new node(l, mid);
		pointerR = new node(mid, r);
		pointerL->build(data);
		pointerR->build(data);
		value = pointerL->value + pointerR->value;
		return;
	}
	void push() {
		if (r - l == 1) return;
		pointerL->value += tag * (pointerL->r - l);
		pointerR->value += tag * (r - pointerR->l);
		pointerL->tag += tag;
		pointerR->tag += tag;
		tag = 0;
	}
	int query(int queryL, int queryR) {
		if (queryL == l && queryR == r) return value;
		push();
		if (queryR <= pointerL->r)
			return pointerL->query(queryL, queryR);
		else if (queryL >= pointerR->l)
			return pointerR->query(queryL, queryR);
		else return pointerL->query(queryL, pointerL->r) +
					pointerR->query(pointerR->l, queryR);
	}
	void modify(int modifyL, int modifyR, int delta) {
		if (modifyL == l && modifyR == r) {
			value += delta * (r - l);
			tag += delta;
			return;
		}
		push();
		if (modifyR <= pointerL->r)
			pointerL->modify(modifyL, modifyR, delta);
		else if (modifyL >= pointerR->l)
			pointerR->modify(modifyL, modifyR, delta);
		else {
			pointerL->modify(modifyL, pointerL->r, delta);
			pointerR->modify(pointerR->l, modifyR, delta);
		}
		// pull
		value = pointerL->value + pointerR->value;
		return;
	}
};
signed main() {
	int n, q;
	cin >> n >> q;
	vector<int> data(n);
	for (int &i : data) cin >> i;
	node st(data);
	for (int mode, l, r, u, k; q--;) {
		cin >> mode;
		if (mode == 1) {
			cin >> l >> r >> u;
			st.modify(l - 1, r, u);
		}
		else {
			cin >> k;
			cout << st.query(k - 1, k) << "\n";
		}
	}
}

# PRESENTING CODE

平衡二元樹

二元
樹

二元樹

🌲

樹結構

根節點

葉節點

分支

根節點的

子節點

節點 + 分支
根節點 : 節點根源
葉節點 : 無子節點
子節點 : 向下連結到的
深度 : 根到此節點的路徑長

樹結構

根節點

葉節點

分支

根節點的

子節點

每個節點至多 2 個子節點

二元樹

二元?

至多兩個子節點

二元樹結構

根節點

葉節點

根節點的

子節點

分支

Segment Tree

Segment Tree

這我

這建北電資

線段樹

線段樹

線段樹

怎麼分區間?

若 nnn 為2的冪次

如果資料長度不是2的冪次

這樣也行

若 nnn 非2的冪次

複雜度

複雜度比較

存樹

指標型存法

陣列型存法 (偽指標型)

4 倍 哪來的

若 nnn 為2的冪次

若 nnn 為2的冪次

若 nnn 不是 2的冪次

迭代式線段樹陣列型存法

2 倍 哪來的

建樹

建樹 遞迴陣列型

線段樹 建樹 code

複雜度分析

查詢

查詢

線段樹 查詢 code

複雜度

單點修改

線段樹 單點修改 code

複雜度

多點修改

懶標

線段樹 懶標下推 code

線段樹 懶標下推 code push()

線段樹 懶標下推 code query()

線段樹 懶標下推 code modify()

複雜度

補充

迭代式線段樹

優點

存圖方式 nnn 為2的冪次

迭代式線段樹 存圖 code

迭代式線段樹 build code

迭代式線段樹 query code

迭代式線段樹 單點修改 code

多點修改

迭代式線段樹 code 懶標

指標型線段樹

指標型線段樹

平衡二元樹

二元樹

🌲

樹 結構

樹結構

樹 結構

二元樹

二元?

二元樹 結構

若 $n$ 為2的冪次

若 $n$ 非2的冪次

4 倍哪來的

若 $n$ 為2的冪次

若 $n$ 為2的冪次

若 $n$ 不是 2的冪次

2 倍哪來的

建樹遞迴陣列型

線段樹建樹 code

線段樹查詢 code

線段樹單點修改 code

線段樹懶標下推 code

線段樹懶標下推 code push()

線段樹懶標下推 code query()

線段樹懶標下推 code modify()

存圖方式 $n$ 為2的冪次

迭代式線段樹存圖 code

迭代式線段樹單點修改 code

樹結構

樹結構

二元樹結構