Segment Tree Beats 学习笔记
Kuriyama_Mirai
·
·
个人记录
Segment Tree Beats 是一种线段树上维护信息的技巧，可用于处理“区间中 \ge k 的数变为 k”此类“区间取最值操作”，由 JRY 在 2016 集训队论文中发表。
<!--more-->
其实思想很简单，就是维护每个结点的最大值与次大值，每次做区间取最值操作时，只有当前结点被修改区间覆盖且次大值小于目标值时才打懒标记返回，否则递归。（当然，如果最大值小于目标值直接返回）
可以证明一般来说复杂度是均摊 O(\log n) 的。
我们还可以同时加上区间加操作，这样复杂度是均摊 O(\log^2 n) 的，但是实际跑起来与 O(\log n) 类似，不过尚未有此更紧的上界的证明。
模板：https://www.luogu.com.cn/problem/P6242
需要维护：
- 区间加
- 区间取 \min
- 区间和
- 区间 \max
- 区间历史 \max
代码：
```cpp
#include <cstdio>
#include <cctype>
#include <algorithm>
namespace mirai {
using ll = long long;
ll read(void) {
char ch;
while ((ch = std::getchar()) != '-' && !std::isdigit(ch));
bool neg = ch == '-';
ll ret = ch == '-' ? 0 : ch - '0';
while (std::isdigit(ch = std::getchar())) {
ret = ret * 10 + ch - '0';
}
return (neg ? -1 : 1) * ret;
}
int buf[30];
void write(ll x) {
int tp = 0;
if (x == 0) {
std::putchar('0');
return;
} else if (x < 0) {
std::putchar('-');
x = -x;
}
while (x) {
buf[tp++] = x % 10;
x /= 10;
}
for (int i = tp - 1; i >= 0; --i) {
std::putchar(buf[i] + '0');
}
return;
}
constexpr int MAXN = 500005;
constexpr ll INF = 0x3f3f3f3f3f3f3f3fll;
int a[MAXN];
class seg_tree {
public:
class node {
public:
int l, r;
ll max, hmax, smax, maxcnt;
ll lzym, lzyhm, lzysm, lzyhsm;
ll sum;
explicit node() {
l = r = 0;
max = hmax = smax = -INF;
maxcnt = 0;
lzym = lzyhm = lzysm = lzyhsm = sum = 0;
}
explicit node(int i) {
l = r = i;
max = hmax = a[i];
maxcnt = 1;
smax = -INF;
lzym = lzyhm = lzysm = lzyhsm = 0;
sum = a[i];
}
} t[MAXN * 4];
void modify(int u, ll lzym, ll lzyhm, ll lzysm, ll lzyhsm) {
t[u].sum += lzym * t[u].maxcnt + lzysm * (t[u].r - t[u].l + 1 - t[u].maxcnt);
t[u].hmax = std::max(t[u].hmax, t[u].max + lzyhm);
t[u].lzyhm = std::max(t[u].lzyhm, t[u].lzym + lzyhm);
t[u].lzyhsm = std::max(t[u].lzyhsm, t[u].lzysm + lzyhsm);
t[u].lzym += lzym;
t[u].lzysm += lzysm;
t[u].max += lzym;
if (t[u].smax != -INF) {
t[u].smax += lzysm;
}
}
void pushdown(int u) {
ll tmp = std::max(t[u * 2].max, t[u * 2 + 1].max);
if (t[u * 2].max == tmp) {
modify(u * 2, t[u].lzym, t[u].lzyhm, t[u].lzysm, t[u].lzyhsm);
} else {
modify(u * 2, t[u].lzysm, t[u].lzyhsm, t[u].lzysm, t[u].lzyhsm);
}
if (t[u * 2 + 1].max == tmp) {
modify(u * 2 + 1, t[u].lzym, t[u].lzyhm, t[u].lzysm, t[u].lzyhsm);
} else {
modify(u * 2 + 1, t[u].lzysm, t[u].lzyhsm, t[u].lzysm, t[u].lzyhsm);
}
t[u].lzym = t[u].lzyhm = t[u].lzysm = t[u].lzyhsm = 0;
}
void pushup(int u) {
t[u].sum = t[u * 2].sum + t[u * 2 + 1].sum;
t[u].hmax = std::max(t[u * 2].hmax, t[u * 2 + 1].hmax);
if (t[u * 2].max == t[u * 2 + 1].max) {
t[u].max = t[u * 2].max;
t[u].maxcnt = t[u * 2].maxcnt + t[u * 2 + 1].maxcnt;
t[u].smax = std::max(t[u * 2].smax, t[u * 2 + 1].smax);
} else if (t[u * 2].max < t[u * 2 + 1].max) {
t[u].max = t[u * 2 + 1].max;
t[u].maxcnt = t[u * 2 + 1].maxcnt;
t[u].smax = std::max(t[u * 2].max, t[u * 2 + 1].smax);
} else {
t[u].max = t[u * 2].max;
t[u].maxcnt = t[u * 2].maxcnt;
t[u].smax = std::max(t[u * 2].smax, t[u * 2 + 1].max);
}
}
void build(int u, int l, int r) {
if (l == r) {
t[u] = node(l);
return;
}
int mid = (l + r) / 2;
t[u].l = l;
t[u].r = r;
build(u * 2, l, mid);
build(u * 2 + 1, mid + 1, r);
pushup(u);
}
void madd(int u, int ql, int qr, ll del) {
if (ql <= t[u].l && t[u].r <= qr) {
modify(u, del, del, del, del);
return;
}
if (qr < t[u].l || t[u].r < ql) { return; }
pushdown(u);
madd(u * 2, ql, qr, del);
madd(u * 2 + 1, ql, qr, del);
pushup(u);
}
void mmin(int u, int ql, int qr, ll tar) {
if (qr < t[u].l || t[u].r < ql || tar >= t[u].max) { return; }
if (ql <= t[u].l && t[u].r <= qr && t[u].smax < tar) {
modify(u, tar - t[u].max, tar - t[u].max, 0, 0);
return;
}
pushdown(u);
mmin(u * 2, ql, qr, tar);
mmin(u * 2 + 1, ql, qr, tar);
pushup(u);
}
ll qsum(int u, int ql, int qr) {
if (ql <= t[u].l && t[u].r <= qr) {
return t[u].sum;
}
if (qr < t[u].l || t[u].r < ql) { return 0ll; }
pushdown(u);
return qsum(u * 2, ql, qr) + qsum(u * 2 + 1, ql, qr);
}
ll qmax(int u, int ql, int qr) {
if (ql <= t[u].l && t[u].r <= qr) {
return t[u].max;
}
if (qr < t[u].l || t[u].r < ql) { return -INF; }
pushdown(u);
return std::max(qmax(u * 2, ql, qr), qmax(u * 2 + 1, ql, qr));
}
ll qhmax(int u, int ql, int qr) {
if (ql <= t[u].l && t[u].r <= qr) {
return t[u].hmax;
}
if (qr < t[u].l || t[u].r < ql) { return -INF; }
pushdown(u);
ll ret = std::max(qhmax(u * 2, ql, qr), qhmax(u * 2 + 1, ql, qr));
return ret;
}
} t;
int main(int argc, char** argv) {
int n, m;
n = read();
m = read();
for (int i = 1; i <= n; ++i) {
a[i] = read();
}
t.build(1, 1, n);
for (int i = 1; i <= m; ++i) {
int op = read();
int l = read();
int r = read();
switch (op) {
case 1: {
ll k = read();
t.madd(1, l, r, k);
break;
}
case 2: {
ll k = read();
t.mmin(1, l, r, k);
break;
}
case 3: {
write(t.qsum(1, l, r));
std::putchar('\n');
break;
}
case 4: {
write(t.qmax(1, l, r));
std::putchar('\n');
break;
}
case 5: {
write(t.qhmax(1, l, r));
std::putchar('\n');
break;
}
}
}
return 0;
}
}
int main(int argc, char** argv) {
return mirai::main(argc, argv);
}
```