模板 - 数据结构 - 线段树/SegmentTree
维护区间的线段树
线段树主要就是在在PushUp和Query的时候注意怎么合并左右区间的信息就可以了。对于延迟标记的互相影响完全就是自己跟自己过不去，假如有多种延迟标记的话不妨在访问到一个区间时全部下推（只需要注意叶子层是不能下推的），从其他部分把常数补回来就可以了。
例1 维护加法和（修改：单点加值 询问：区间加法和）
struct SegmentTree {
#define ls (o<<1)
#define rs (o<<1|1)
static const int MAXN = 100000;
ll a[MAXN + 5];
ll st[(MAXN << 2) + 5];
void PushUp(int o) {
st[o] = st[ls] + st[rs];
}
void Build(int o, int l, int r) {
if(l == r)
st[o] = a[l];
else {
int m = l + r >> 1;
Build(ls, l, m);
Build(rs, m + 1, r);
PushUp(o);
}
}
void Update(int o, int l, int r, int p, ll v) {
if(l == r) {
st[o] += v;
return;
} else {
int m = l + r >> 1;
if(p <= m)
Update(ls, l, m, p, v);
if(p >= m + 1)
Update(rs, m + 1, r, p, v);
PushUp(o);
}
}
ll Query(int o, int l, int r, int ql, int qr) {
if(ql <= l && r <= qr) {
return st[o];
} else {
int m = l + r >> 1;
ll res = 0;
if(ql <= m)
res = res + Query(ls, l, m, ql, qr);
if(qr >= m + 1)
res = res + Query(rs, m + 1, r, ql, qr);
return res;
}
}
#undef ls
#undef rs
};
例2 维护加法和（修改：区间加值 询问：区间加法和）
struct SegmentTree {
#define ls (o<<1)
#define rs (o<<1|1)
static const int MAXN = 100000;
ll a[MAXN + 5];
ll st[(MAXN << 2) + 5], lazy[(MAXN << 2) + 5];
void PushUp(int o) {
st[o] = st[ls] + st[rs];
}
void PushDown(int o, int l, int r) {
if(lazy[o]) {
lazy[ls] += lazy[o];
lazy[rs] += lazy[o];
int m = l + r >> 1;
st[ls] += lazy[o] * (m - l + 1);
st[rs] += lazy[o] * (r - m);
lazy[o] = 0;
}
}
void Build(int o, int l, int r) {
if(l == r)
st[o] = a[l];
else {
int m = l + r >> 1;
Build(ls, l, m);
Build(rs, m + 1, r);
PushUp(o);
}
lazy[o] = 0;
}
void Update(int o, int l, int r, int ql, int qr, ll v) {
if(ql <= l && r <= qr) {
lazy[o] += v;
st[o] += v * (r - l + 1);
return;
} else {
PushDown(o, l, r);
int m = l + r >> 1;
if(ql <= m)
Update(ls, l, m, ql, qr, v);
if(qr >= m + 1)
Update(rs, m + 1, r, ql, qr, v);
PushUp(o);
}
}
ll Query(int o, int l, int r, int ql, int qr) {
if(ql <= l && r <= qr) {
return st[o];
} else {
PushDown(o, l, r);
int m = l + r >> 1;
ll res = 0;
if(ql <= m)
res = res + Query(ls, l, m, ql, qr);
if(qr >= m + 1)
res = res + Query(rs, m + 1, r, ql, qr);
return res;
}
}
#undef ls
#undef rs
};
例3 维护最大最小值（修改：区间加值 询问：区间最大最小值）
struct SegmentTree {
#define ls (o<<1)
#define rs (o<<1|1)
static const int MAXN = 1000000;
static const int INF = 0x3f3f3f3f;
int mi[(MAXN << 2) + 5];
int ma[(MAXN << 2) + 5];
int lz[(MAXN << 2) + 5];
void PushUp(int o) {
mi[o] = min(mi[ls], mi[rs]);
ma[o] = max(ma[ls], ma[rs]);
}
void PushDown(int o, int l, int r) {
if(lz[o]) {
lz[ls] += lz[o];
lz[rs] += lz[o];
//int m = l + r >> 1;
mi[ls] += lz[o];
mi[rs] += lz[o];
ma[ls] += lz[o];
ma[rs] += lz[o];
lz[o] = 0;
}
}
void Build(int o, int l, int r) {
if(l == r) {
mi[o] = 0;
ma[o] = 0;
} else {
int m = l + r >> 1;
Build(ls, l, m);
Build(rs, m + 1, r);
PushUp(o);
}
lz[o] = 0;
}
void Update(int o, int l, int r, int ql, int qr, int v) {
if(ql <= l && r <= qr) {
lz[o] += v;
mi[o] += v;
ma[o] += v;
} else {
PushDown(o, l, r);
int m = l + r >> 1;
if(ql <= m)
Update(ls, l, m, ql, qr, v);
if(qr >= m + 1)
Update(rs, m + 1, r, ql, qr, v);
PushUp(o);
}
}
int QueryMin(int o, int l, int r, int ql, int qr) {
if(ql <= l && r <= qr) {
return mi[o];
} else {
PushDown(o, l, r);
int m = l + r >> 1;
int res = INF;
if(ql <= m)
res = QueryMin(ls, l, m, ql, qr);
if(qr >= m + 1)
res = min(res, QueryMin(rs, m + 1, r, ql, qr));
return res;
}
}
int QueryMax(int o, int l, int r, int ql, int qr) {
if(ql <= l && r <= qr) {
return ma[o];
} else {
PushDown(o, l, r);
int m = l + r >> 1;
int res = -INF;
if(ql <= m)
res = QueryMax(ls, l, m, ql, qr);
if(qr >= m + 1)
res = max(res, QueryMax(rs, m + 1, r, ql, qr));
return res;
}
}
#undef ls
#undef rs
} st;
这种线段树可以简单拓展：加多一个标记，记录这个区间的最值出自哪个元素。尤其容易维护出最左侧/最右侧的最值。
维护值域的线段树（权值线段树）
需要先离线所有可能的取值，然后离散化到线段树可以接受的空间范围。每个节点存当前的值域的信息，最简单的应用是维护当前值域的元素共有多少个。那么可以在线段树上二分，返回当前线段树中的第k大。这种情形用于在某些情况下替代平衡树的功能，优点是常数相对平衡树而言很小，对于插入数据的顺序有要求，有时可能还要求离线。真正在线维护全树第k大的只有平衡树。
struct SegmentTree {
#define ls (o<<1)
#define rs (o<<1|1)
static const int MAXN = 100000;
int cnt[(MAXN << 2) + 5];
void PushUp(int o) {
cnt[o] = cnt[ls] + cnt[rs];
}
void Build(int o, int l, int r) {
if(l == r)
cnt[o] = 0;
else {
int m = l + r >> 1;
Build(ls, l, m);
Build(rs, m + 1, r);
PushUp(o);
}
}
//修改值为p的元素的个数，增量为v，且不能为负
void Update(int o, int l, int r, int p, int v) {
if(l == r) {
cnt[o] += v;
if(cnt[o] < 0)
cnt[o] = 0;
return;
} else {
int m = l + r >> 1;
if(p <= m)
Update(ls, l, m, p, v);
if(p >= m + 1)
Update(rs, m + 1, r, p, v);
PushUp(o);
}
}
//查询<=x的元素的个数
int GetRank(int o, int l, int r, int x) {
if(r <= x) {
return cnt[o];
} else {
int m = l + r >> 1;
if(x <= m)
return GetRank(ls, l, m, x);
else
return cnt[ls] + GetRank(rs, m + 1, r, x);
}
}
//查询最小的x，使得<=x的元素个数>=rk（第rk小）
int GetValue(int o, int l, int r, int rk) {
if(l == r) {
return l;
} else {
int m = l + r >> 1;
if(cnt[ls] >= rk)
return GetValue(ls, l, m, rk);
else
return GetValue(rs, m + 1, r, rk - cnt[ls]);
}
}
#undef ls
#undef rs
} st;
注意：这里面传入的参数都应该是离散化之后的值。权值线段树不能用一次递归实现GetPrev()和GetNext()，需要通过给离散化的值做出一些修改，然后组合GetRank()和GetNext()才可以实现。优势在于代码短，常数小。
动态开点权值线段树
不再需要提前离散化了。
