无旋treap大法好
无旋Treap大法好
原理?
- 是一棵二叉查找树: 一个节点左子树权值都比他小,右子树权值都比他大
- 所以可以维护序列(以位置为权值),或数值(以数值为权值)
- 是一个堆: 每个节点除了上述提到的权值外,还有一个随机生成的给堆用的优先级
- 好像有了随机+堆就可以使树高均摊\(O(log_2^n)\)?,怎么证明呢?
用分裂和合并两个操作为基础,写起来会比较清真
基本操作
结构体的组成
struct Treap
{
LL val, pri; //数值, 优先级
int cnt, siz, ch[2]; // 计数, 子树大小, 左右儿子
//还可以加一些标记,如这个子树翻转的标记
Treap() {}
Treap(int _val) { val = _val, pri = rand(), cnt = siz = 1, ch[0] = ch[1] = 0; }
} t[MAXN];
split(按数值)
这两个分裂的代码看了很久才看懂
split(int now, int val, int & x, int & y)意思是将\(now\)为根的这棵子树, \(<=val\)的部分分裂, 并将他的根记录在\(x\)上, \(y\)同理
那么怎么递归实现呢?
主要思路是一旦碰到能整棵子树都\(或>val 或<=val\)就整棵一起分割
注意在当前子树的根\(now\)分裂的时候, 只能确保一边的整棵子树完全归属\(<=val\)或\(>val\)的部分
例如当val < t[now].val, 只能确定整棵右子树及\(now\)都\(>val\),所以现将\(y\)赋值为他们的根(\(now\)),
但是在左子树仍可能有\(>val\)的节点, 所以将\(now\)的左子作为参数传递, 意在后来分离出的\(>val\)的节点接在\(now\)上
而现在还并不能分离\(<=val\)的某棵子树, 于是将传递过来的\(x\)继续传下去
另一种情况类似
void split(int now, int val, int & x, int & y) // <=val --> x, > val --> y
{
if (!now) return (void)(x = y = 0);
if (val < t[now].val) y = now, split(ls, val, x, ls);
else x = now, split(rs, val, rs, y);
update(now);
}
split(按大小)
void split_k(int now, int k, int & x, int & y) // 当前分割跟为now的子树， 并将<=k的根连到x(赋值给x)，y同理
{
if (!now) return (void)(x = y = 0); //不断往下分，分完了
if (k <= t[ls].siz) y = now, split_k(ls, k, x, ls); // 确定根及右子树都>k，所以先分出他们，然后去分左子树， 将剩下的>k连回左子，<=k的连向x
else x = now, split_k(rs, k - t[ls].siz - 1, rs, y); // 确定根及左子树<=k, 分出他们，然后分右子树，将右子树中<=k的连回右子，>k的连向y
update(now);
}
merge
int merge(int x, int y) // max_x < min_y
{
if (!x || !y) return x + y;
if (t[x].pri < t[y].pri)
{
t[x].ch[1] = merge(t[x].ch[1], y);
update(x);
return x;
}
else
{
t[y].ch[0] = merge(x, t[y].ch[0]);
update(y);
return y;
}
}
LL kth(int k)
{
int now = root;
while (1)
{
if (t[rs].siz >= k) now = rs;
else if (t[rs].siz + 1 < k) k -= t[rs].siz + 1, now = ls;
else return t[now].val;
}
}
例题1
BZOJ1500,NOI2005,维修数列
用这道毒瘤题具体分析一些\(Treap\)支持的操作
题意概述
维护一个数列,
要求区间插入/删除/统一修改/翻转/求和, 求当前整个数列最大子段和(至少包含一个数)
任何时刻数列中最多含有500 000个数，数列中任何一个数字均在[-1 000, 1 000]内。
插入的数字总数不超过4 000 000个，输入文件大小不超过20MBytesN 和M(M ≤20 000
.png)
样例
Sample Input
9 8
2 -6 3 5 1 -5 -3 6 3
GET-SUM 5 4
MAX-SUM
INSERT 8 3 -5 7 2
DELETE 12 1
MAKE-SAME 3 3 2
REVERSE 3 6
GET-SUM 5 4
MAX-SUMSample Output
-1
10
1
10
\(Treap\)的具体操作
\(O(n)\)建树
主要用于对数列的建树, 比一个一个插入优良一点
思路是: 对于一个新的节点, 他一定在之前节点构成的\(Treap\)的右边(废话),
所以想象一下把他从右边插入, 找到最右边那条链上第一个堆的优先级比他大的位置, 把他和他的整棵子树切下来, 把新节点换上去, 再结回新节点的左儿子
可以用栈实现
int newnode(int val)
{
int now = renode ? recyc[renode --] : ++totnode; // 循环利用
t[now] = Treap(val);
return now;
}
int build(int tot)
{
for (int i = 1; i <= tot; ++ i)
{
int now = newnode(in()), rec = 0;
while (top && t[now].pri < t[stk[top]].pri)
update(stk[top]), rec = stk[top --];
if (top) t[stk[top]].ch[1] = now;
t[now].ch[0] = rec;
stk[++top] = now;
}
while (top) update(stk[top --]);
return stk[1];
}
分离出一个区间
例如将\([l, r]\)分离到\(y\)上
int x = 0, y = 0, z = 0;
split(root, l - 1, x, y); // x <= l-1, y >= l
split(y, r - l + 1, y, z); // y [l, r]
insert一个点
int newnode(int val)
{
t[++tot] = Treap(val);
return tot;
}
void insert(int val)
{
int x = 0, y = 0, xx = 0, xy = 0;
split(root, val, x, y);
root = merge(merge(x, newnode(val)), y);
}
insert一个区间
void insert(int pos, int tot) // ok
{
int x, y;
split(root, pos, x, y);
root = merge(merge(x, build(tot)), y);
}
delete一个区间
void delet(int pos, int tot)
{
int x, y, z;
split(root, pos - 1, x, y);
split(y, tot, y, z);
root = merge(x, z);
eat(y); // 回收
}
第k大
LL kth(int k)
{
int now = root;
while (1)
{
if (t[rs].siz >= k) now = rs;
else if (t[rs].siz + 1 < k) k -= t[rs].siz + 1, now = ls;
else return t[now].val;
}
}
关于打标记
因为要保证update(now)时左右两个儿子的信息已经更新, 所以标记代表本节点已经修改,子树需要修改,这样比较好
下面就是两种标记
区间翻转
先分离出要翻转的区间, 打上标记
不用担心之后这个有标记的根不是恰好代表这段区间
因为之后的合并/分裂操作, 一旦需要改变某个节点\(x\)在树中的结构, 就会立马下传标记, 并且之后会向上更新
void markrev(int now) // 标记这个子树需要翻转, 意味着子树内每个点左右儿子都交换
{
if (!now) return ;
t[now].rev ^= 1;
swap(t[now].pre, t[now].suf); // 用于维护区间最大子段和, 区间交换那么前缀和后缀也要交换
swap(ls, rs);
}
void reverse(int l, int r)
{
int x = 0, y = 0, z = 0;
split(root, l - 1, x, y); // x <= l-1, y >= l
split(y, r - l + 1, y, z); // y [l, r]
markrev(y); // !
root = merge(merge(x, y), z);
}
区间赋值
和翻转类似
void markcov(int now, int cov)
{
if (!now) return ;
t[now].val = t[now].cov = cov;
t[now].sum = t[now].val * t[now].siz;
t[now].pre = t[now].suf = max(t[now].sum, 0);
t[now].maxsum = max(t[now].sum, t[now].val);
}
void modify(int l, int r, int c)
{
int x, y, z;
split(root, l - 1, x, y);
split(y, r - l + 1, y, z);
markcov(y, c); // !
root = merge(merge(x, y), z);
}
区间求和
每个节点维护子树内的权值就可以了, 具体的维护下面区间修改的更新中说明
int getsum(int l, int r)
{
int x, y, z, ret;
split(root, l - 1, x, y);
split(y, r - l + 1, y, z);
ret = t[y].sum;
root = merge(merge(x, y), z);
return ret;
}
\(和相关pushdown() 和 update() 相关\)
之前已经说过, 打标记时就修改此节点的信息, 而标记表示子树需要修改
单独写了加上标记的函数(结合之前几段代码)
void pushdown(int now)
{
if (!now) return ;
if (t[now].rev)
{
markrev(ls), markrev(rs);
t[now].rev = 0;
}
if (t[now].cov != 10000) //
{
markcov(ls, t[now].cov), markcov(rs, t[now].cov);
t[now].cov = 10000;
}
}
更新是确保子树信息正确
void update(int now) // ls ans rs 's info must be right
{
t[now].siz = t[ls].siz + t[rs].siz + 1;
t[now].sum = t[ls].sum + t[rs].sum + t[now].val;
t[now].pre = max(max(t[ls].pre, t[ls].sum + t[now].val + t[rs].pre), 0);
t[now].suf = max(max(t[rs].suf, t[rs].sum + t[now].val + t[ls].suf), 0);
t[now].maxsum = t[now].val + t[ls].suf + t[rs].pre;
if (ls) t[now].maxsum = max(t[now].maxsum, t[ls].maxsum);
if (rs) t[now].maxsum = max(t[now].maxsum, t[rs].maxsum);
}
垃圾回收, 节省空间
int newnode(int val)
{
int now = renode ? recyc[renode --] : ++totnode;
t[now] = Treap(val);
return now;
}
void eat(int now)
{
if (!now) return ;
eat(ls); eat(rs);
recyc[++renode] = now;
}
void delet(int pos, int tot)
{
int x, y, z;
split(root, pos - 1, x, y);
split(y, tot, y, z);
root = merge(x, z);
eat(y);
}
BZOJ1500 代码
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
const int MAXN = 5e5 + 10;
inline int in()
{
int x = 0, flag = 1; char ch = getchar();
while (ch < '0' || ch > '9') { if (ch == '-') flag = -1; ch = getchar(); }
while (ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * flag;
}
int n, m;
#define ls (t[now].ch[0])
#define rs (t[now].ch[1])
int root, totnode;
int recyc[MAXN], renode;
struct Treap
{
int val, pri, siz, ch[2], rev, cov, sum, pre, suf, maxsum;
Treap() {}
Treap(int _val)
{
sum = val = _val, pri = rand(), siz = 1, ch[0] = ch[1] = rev = 0;
maxsum = pre = suf = max(0, val);
cov = 1e4;
}
} t[MAXN];
void markrev(int now) //ok
{
if (!now) return ;
t[now].rev ^= 1;
swap(t[now].pre, t[now].suf);
swap(ls, rs);
}
void markcov(int now, int cov) // ok
{
if (!now) return ;
t[now].val = t[now].cov = cov;
t[now].sum = t[now].val * t[now].siz;
t[now].pre = t[now].suf = max(t[now].sum, 0);
t[now].maxsum = max(t[now].sum, t[now].val);
}
void pushdown(int now)
{
if (!now) return ;
if (t[now].rev)
{
markrev(ls), markrev(rs);
t[now].rev = 0;
}
if (t[now].cov != 10000) //
{
markcov(ls, t[now].cov), markcov(rs, t[now].cov);
t[now].cov = 10000;
}
}
void update(int now) // ls ans rs 's info must be right
{
t[now].siz = t[ls].siz + t[rs].siz + 1; // ok
t[now].sum = t[ls].sum + t[rs].sum + t[now].val; // ok
t[now].pre = max(max(t[ls].pre, t[ls].sum + t[now].val + t[rs].pre), 0);
t[now].suf = max(max(t[rs].suf, t[rs].sum + t[now].val + t[ls].suf), 0);
t[now].maxsum = t[now].val + t[ls].suf + t[rs].pre;
if (ls) t[now].maxsum = max(t[now].maxsum, t[ls].maxsum);
if (rs) t[now].maxsum = max(t[now].maxsum, t[rs].maxsum);
//pay attention
}
void split(int now, int k, int & x, int & y)
{
if (!now) return (void)(x = y = 0);
pushdown(now);
if (k <= t[ls].siz) y = now, split(ls, k, x, ls);
else x = now, split(rs, k - t[ls].siz - 1, rs, y);
update(now);
}
int merge(int x, int y) // max_x < min_y
{
pushdown(x); pushdown(y);
if (!x || !y) return x + y;
if (t[x].pri < t[y].pri)
{
t[x].ch[1] = merge(t[x].ch[1], y);
update(x);
return x;
}
else
{
t[y].ch[0] = merge(x, t[y].ch[0]);
update(y);
return y;
}
}
int newnode(int val)
{
int now = renode ? recyc[renode --] : ++totnode;
t[now] = Treap(val);
return now;
}
int stk[MAXN], top;
int build(int tot) // ok
{
for (int i = 1; i <= tot; ++ i)
{
int now = newnode(in()), rec = 0;
while (top && t[now].pri < t[stk[top]].pri)
update(stk[top]), rec = stk[top --];
if (top) t[stk[top]].ch[1] = now;
t[now].ch[0] = rec;
stk[++top] = now;
}
while (top) update(stk[top --]);
return stk[1];
}
void insert(int pos, int tot) // ok
{
int x, y;
split(root, pos, x, y);
root = merge(merge(x, build(tot)), y);
}
void eat(int now)
{
if (!now) return ;
eat(ls); eat(rs);
recyc[++renode] = now;
}
void delet(int pos, int tot)
{
int x, y, z;
split(root, pos - 1, x, y);
split(y, tot, y, z);
root = merge(x, z);
eat(y);
}
int getsum(int l, int r) // ok
{
int x, y, z, ret;
split(root, l - 1, x, y);
split(y, r - l + 1, y, z);
ret = t[y].sum;
root = merge(merge(x, y), z);
return ret;
}
int maxsum() //ok
{
return t[root].maxsum;
}
void modify(int l, int r, int c) // ok
{
int x, y, z;
split(root, l - 1, x, y);
split(y, r - l + 1, y, z);
markcov(y, c);
root = merge(merge(x, y), z);
}
void reverse(int l, int r) // ok
{
int x = 0, y = 0, z = 0;
split(root, l - 1, x, y); // x <= l-1, y >= l
split(y, r - l + 1, y, z); // y [l, r]
markrev(y);
root = merge(merge(x, y), z);
}
#undef ls
#undef rs
char opt[15];
int main()
{
n = in(), m = in();
root = build(n);
int pos, tot;
while (m --)
{
scanf("%s", opt + 1);
if (opt[3] == 'X') // MAX-SUM 当前最子段和
printf("%d\n", maxsum());
else
{
pos = in(), tot = in();
if (opt[1] == 'G') // GET-SUM 从pos开始tot个数的和
printf("%d\n", getsum(pos, pos + tot - 1));
else if (opt[1] == 'I') // INSERT 在pos之后插入a[1~tot]
insert(pos, tot);
else if (opt[1] == 'D') // DELETE 删除从pos开始tot位
delet(pos, tot);
else if (opt[3] == 'K') // MAKE-SAME 将pos开始tot位修改为c
modify(pos, pos + tot - 1, in());
else if (opt[1] == 'R') // REVERSE 翻转从pos开始tot位
reverse(pos, pos + tot - 1);
}
}
return 0;
}
/*201907122010 ~ 201907131247*/
