线段树 (区间查询)

线段树是一种二元树，可视为树状数组的变种，
线段树是一种将数组存储为树的数据结构。这允许高效地回答数组上的范围查询，同时仍然足够灵活以允许快速修改数组。
这包括查找连续数组元素formula_1 的总和，或在formula_2 时间内找到此类范围内的最小元素（范围最值查询）。在回答此类查询之间，线段树允许通过替换一个元素甚至更改整个子段的元素来修改数组（例如，将所有元素formula_1 分配给任何值，或为子段中的所有元素增加一个值）。
通常，线段树是一种非常灵活的数据结构，可以用它解决大量问题。此外，还可以应用更复杂的操作并回答更复杂的查询。特别是，线段树可以轻松推广到更大的维度。例如，使用二维线段树，只需formula_4 时间即可回答给定矩阵中某个子矩形的总和或最小值查询。线段树的一个重要特性是它们只需要线性量的内存，通常需要4n个顶点来处理大小为n的数组。
结构.
线段树是一个平衡的二叉树，它将每个长度不为1的区间划分成左右两个区间递归求解。令整个区间的长度为N，则其有N个叶节点，每个叶节点代表一个单位区间，每个内部结点代表的区间为其两个儿子代表区间的联集。这种数据结构可以方便的进行大部分的区间操作。
基本操作.
线段树所要提供的是查询一个区间formula_5内的子问题的答案formula_6，并允许修改操作。要使用线段树，此资讯大部分情况下需要满足对于区间formula_5与位于区间内的一点formula_8，formula_6要可以由formula_10、formula_11求得。例如范围最值查询即符合此条件。线段树维护的信息大部分情况需要符合半群的性质，但有例外，像是可以动态维护最大子数列问题，虽无法透过formula_10、formula_11求得formula_6，但可以透过维护多个资料在同一线段树节点维护每个区间的子问题。
代码中, formula_15指的是formula_16, 当前子树的根节点; formula_17指的是当前子树所统计的区间formula_18利用完全二叉堆的性质来保存节点编号, 所以formula_19(即formula_20)是左子树的节点, formula_21(即formula_22)是右子树的节点在查询和成端更新操作中的L和R是指修改或者查询的区间
节点数据向上更新.
将子节点的值更新到父节点，即合并两个子问题。
/* 对于区间求和 */
void push_up(int rt) {
 tree[rt] = tree[rt « 1] + tree[rt « 1 | 1];
/* 对于区间求最大值 */
void push_up(int rt) {
 tree[rt] = max(tree[rt « 1], tree[rt « 1 | 1]);
节点懒惰标记下推.
对于区间求和, 原子数组值需要加上lazy标记乘以子树所统计的区间长度。
len为父节点统计的区间长度, 则len - (len » 1) (即 formula_23)为左子树区间长度, len » 1 (即 formula_24)为右子树区间长度。
void push_down(int rt, int len) {
 tree[rt « 1] += lazy[rt] * (len - (len » 1));
 lazy[rt « 1] += lazy[rt];
 tree[rt « 1 | 1] += lazy[rt] * (len » 1);
 lazy[rt « 1 | 1] += lazy[rt];
 lazy[rt] = 0;
对于区间求最大值, 子树的值不需要乘以长度, 所以不需要传递参数len。
void push_down(int rt) {
 tree[rt « 1] += lazy[rt];
 lazy[rt « 1] += lazy[rt];
 tree[rt « 1 | 1] += lazy[rt];
 lazy[rt « 1 | 1] += lazy[rt];
 lazy[rt] = 0;
建树.
新建一棵长度N的线段树，有时也会使用更新函式代替以减少代码量。
void build(int rt = 1, int l = 1, int r = N) {
 int m = (l + r) » 1;
 build(lchild); build(rchild);
 push_up(rt);
更新.
单点更新, 不需要用到lazy标记
void update(int p, int delta, int rt = 1, int l = 1, int r = N) {
 if (l == r) {
 tree[rt] += delta;
 return;
 int m = (l + r) » 1;
 if (p &lt;= m) update(p, delta, lchild);
 else update(p, delta, rchild);
 push_up(rt);
成段更新, 需要用到lazy标记来提高时间效率。
如果要求修改区间，把所有包含在区间中的节点都遍历一次、修改一次，时间复杂度太高。所以要有 「懒惰标记」（lazy标记） 。
懒惰标记就是通过延迟对节点信息的更改，从而减少不必要的操作次数。每次执行修改时，通过打标记的方法表明该节点对应的区间在某一次操作中被更改，但不更新该节点的子节点的信息，实质性的修改则在下一次访问带有标记的节点时才进行。
void update(int L, int R, int delta, int rt = 1, int l = 1, int r = N) {
 if (L &lt;= l &amp;&amp; r &lt;= R) {
 tree[rt] += delta * (r - l + 1);
 lazy[rt] += delta;
 return;
 if (lazy[rt]) push_down(rt, r - l + 1);
 int m = (l + r) » 1;
 if (L &lt;= m) update(L, R, delta, lchild);
 if (R &gt; m) update(L, R, delta, rchild);
 push_up(rt);
区间查询.
int query(int L, int R, int rt = 1, int l = 1, int r = N) {
 if (L &lt;= l &amp;&amp; r &lt;= R) return tree[rt];
 if (lazy[rt]) push_down(rt, r - l + 1);
 int m = (l + r) » 1, ret = 0;
 if (L &lt;= m) ret += query(L, R, lchild);
 if (R &gt; m) ret += query(L, R, rchild);
 return ret;
可直接使用的编程模板.
using namespace std;
namespace SegTree {
 #define maxn 1000000
 class SegmentTree {
 #define lson (o«1)
 #define rson (o«1|1)
 #define mid ((l+r)»1)
 public :
 int addv[maxn], maxv[maxn], minv[maxn], sumv[maxn];
 int arr[maxn];
 int N;
 public : int pushup(int o) {
 minv[o] = _min(minv[lson], minv[rson]);
 maxv[o] = _max(maxv[lson], maxv[rson]);
 sumv[o] = sumv[lson] + sumv[rson];
 return 0;
 public : int pushdown(int o, int l, int r) {
 if(addv[o] == 0) return -1;
 addv[lson] += addv[o]; addv[rson] += addv[o];
 minv[lson] += addv[o]; minv[rson] += addv[o];
 maxv[lson] += addv[o]; maxv[rson] += addv[o];
 sumv[lson] += addv[o] * (mid-l+1); sumv[rson] += addv[o] * (r-mid);
 addv[o] = 0;
 public : int Build(int o, int l, int r) {
 addv[o] = 0;
 if(l == r) {
 maxv[o] = arr[l];minv[o] = arr[l];sumv[o] = arr[l];
 return 0;
 Build(lson, l, mid);
 Build(rson, mid+1, r);
 pushup(o);
 return 0;
 public : int optadd(int o, int l, int r, int ql, int qr, int addval) {
 if(ql &gt; r or qr &lt; l) return 0;
 if(ql &lt;= l and r &lt;= qr) {
 addv[o] += addval;
 sumv[o] += addval * (r-l+1);
 return 0;
 pushdown(o, l, r);
 optadd(lson, l, mid, ql, qr, addval);
 optadd(rson, mid+1, r, ql, qr, addval);
 pushup(o);
 public : int query_sum(int o, int l, int r, int ql, int qr) {
 if(ql &gt; r or qr &lt; l) return 0;
 if(ql &lt;= l and r &lt;= qr) {
 return sumv[o];
 pushdown(o, l, r);
 return query_sum(lson, l, mid, ql, qr) + query_sum(rson, mid+1, r, ql, qr);
 public : int query_min(int o, int l, int r, int ql, int qr) {
 if(ql &gt; r or qr &lt; l) return 0;
 if(ql &lt;= l and r &lt;= qr) {
 return minv[o];
 pushdown(o, l, r);
 return _min(query_min(lson, l, mid, ql, qr), query_min(rson, mid+1, r, ql, qr));
 public : int query_max(int o, int l, int r, int ql, int qr) {
 if(ql &gt; r or qr &lt; l) return 0;
 if(ql &lt;= l and r &lt;= qr) {
 return maxv[o];
 pushdown(o, l, r);
 return _max(query_max(lson, l, mid, ql, qr), query_max(rson, mid+1, r, ql, qr));
 };
//End of SegmentTree
using namespace SegTree;
变种.
zkw线段树是一种自底向上的线段树，由清华大学的张昆玮提出。它相对于传统线段树的优势体现在减少了递归操作和增加了位运算等操作以减少常数。