Segment Tree

死線斷裂術

建北電資小社課演算法

Segment Tree

線段樹

線段樹建樹 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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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

線段樹查詢 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);
	}
}; #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);
	}
}; #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);
	}
}; #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);
	}
}; #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);
	}
}; #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);
	}
}; #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

線段樹單點修改 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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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$ 的位置

線段樹懶標下推 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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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$ 修改增加值

迭代式線段樹存圖 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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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;
	}
}; #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

Segment Tree 死線斷裂術建北電資小社課演算法 Segment Tree 線段樹

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

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

	#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;
	}
	};

Segment Tree

Segment Tree

SegmentTree

More from 建中店自計算機研習社學術長807⁸⁰⁷