splay 简要讲解
前置芝士:普通二叉树
splay tree是一个越处理越灵活的数据结构,通过splay(伸展)操作,使整棵树的单次查询时间复杂度接近于O(log n),整棵树的高度也接近于log n
根据上面的这句话,很明显能看出splay与普通二叉树的区别
普通二叉树经过多次处理后,很容易退化成链,单次查询的复杂度直升O(n),对于处理大型数据来说,这是绝对不能允许的
OI和ACM界也经常会有数据能使一个普通二叉树快速退化成链
例: 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9
很明显,对于大型数据的处理来说,普通二叉树已经满足不了了
下面,我将会以例图来讲解中序遍历
这张图是我偷的,哈哈
在这组数据中,数的根节点为6,整棵树的中序遍历为1,2,3,4,5,6,7,10,15，一个树的中序遍历为：左子树 + 根 + 右子树
很明显,这是递增的，当前这个splay树维护的是一个递增的序列
________________________________
操作
_______________
splay 有一个核心操作,就叫splay(伸展)
splay操作是依靠rotate去实现的
rotate(x) 点x向上翻转，分左旋和右旋,使其中序遍历不变,详情见代码
（关键是将这玩意得要图，要不不好讲清，如果代码看不懂的话，点这里，至OI wiki)splay(x,k) 将点x翻转到点k的下方,每次添加一个数,就将其splay到根节点的下方(每次翻转的复杂度为log n),这样的话就能使整棵树的高度接近于log n
-------------------------------
在树中每个点的前继(succ)就是其在数组中的上一个点,后继(pred)就是下一个点,
kth 查询第k大的数,在树中每个点的前继就是其在数组中的上一个点,后继就是下一个点,所以在其中序遍历有序的前提下,递归判断每个子树的大小就行了
当然，p2042这道题的kth是第k个数，并不是第k大的数，因为这道题(p2042)维护的是一个区间
---------
build(or insert) 创建子树(或插入一个数)
如果我们要创建一段数字,插入到下标x的后面,想一下，是不是可以先在这组将要插入的数中建树，然后直接将这个树插到下标为x的右子树下，是不是就可以了？
同样,insert(x)也是同理,只不过是其子树的大小只有1
---------
detele操作,垃圾回收
每一次delete(x)后，tree[x]这个点为空，是不是浪费了？这很不符合我们环保的心理 (=_=) ，所以在每次我们delete操作后，将其节点下标保存下来，到build(or insert)的时候再使用，这样是不是就做到回收再利用了？
---------------
当我们想要处理区间 [x,y] 的时候，记住无论我们怎么splay，其中序遍历一定不变，再想想，在splay中一个点的前继和后继是什么
所以我们就可以现将x splay到根节点的下方，将y splay到x的下方，其 [x,y] 是不是就是点x及其右子树 和 点y及其左子树，然后就可以区间处理了
___________________________________________
记住，splay所维护的可以不是一个数组的val值，他可以是数组的下标
___________________________________________
一切尽在注释之中，这道题所维护的是每一个点的下标，并不是其点的val
例题:P2042 [NOI2005] 维护数列
splay+垃圾回收
#include"bits/stdc++.h"
using namespace std;
const int N = 500010,INF = 1e9;
#define inl inline
#define reg register
//#define ll long long
int n,m;
struct node
{
int s[2],p,v;
int rev,same,size,sum,ms,ls,rs;
//翻转标记,相同标记,子树大小,区间和,最大子段和,最大前缀和,最大后缀和
inl void init(int _v,int _p) //预处理
{
s[0] = s[1] = 0,p = _p,v = _v;
rev = same = 0;
size = 1,sum = ms =v;
ls = rs = max(v,0);
}
}tr[N];
int root;
int nodes[N],tt;//垃圾回收数组,tt为其大小
int w[N];
inl void pushup(int x) //向上传递
{
auto &u = tr[x],&l = tr[u.s[0]],&r = tr[u.s[1]];
u.size = l.size + r.size + 1;
u.sum = l.sum + r.sum + u.v;
u.ls = max(l.ls,l.sum + u.v + r.ls);
u.rs = max(r.rs,r.sum + u.v + l.rs);
u.ms = max(max(l.ms,r.ms),l.rs + u.v + r.ls);
//处理各个数据
}
inl void pushdown(int x) //向下传递
{
auto &u = tr[x],&l = tr[u.s[0]], &r = tr[u.s[1]];
if(u.same) //若有相同标记,则翻转标记就并不需要
{
u.same = u.rev = 0;
if(u.s[0]) l.same = 1,l.v = u.v,l.sum = l.v * l.size;
if(u.s[1]) r.same = 1,r.v = u.v,r.sum = r.v * r.size;
if(u.v > 0)
{
if(u.s[0]) l.ms = l.ls = l.rs = l.sum;
if(u.s[1]) r.ms = r.ls = r.rs = r.sum;
}else
{
if(u.s[0]) l.ms = l.v,l.ls = l.rs = 0;
if(u.s[1]) r.ms = r.v,r.ls = r.rs = 0;
}
//左右子树数据处理
}else
if(u.rev)
{
u.rev = 0,l.rev ^= 1,r.rev ^= 1;
swap(l.ls,l.rs),swap(r.ls,r.rs);
swap(l.s[0],l.s[1]),swap(r.s[0],r.s[1]);
//翻转
}
}
inl void rotate(int x)
{
int y = tr[x].p,z = tr[y].p;
int k = tr[y].s[1] == x;
tr[z].s[tr[z].s[1] == y] = x,tr[x].p = z;
tr[y].s[k] = tr[x].s[k ^ 1],tr[tr[x].s[k ^ 1]].p = y;
tr[x].s[k ^ 1] = y,tr[y].p = x;
pushup(y),pushup(x);
//向上旋转
}
inl void splay(int x,int k)
{
while (tr[x].p != k)
{
int y = tr[x].p, z = tr[y].p;
if (z != k)
if ((tr[y].s[1] == x) ^ (tr[z].s[1] == y)) rotate(x);
else rotate(y);
rotate(x);
}
if (!k) root = x;
}
//伸展
inl int get_k(int k) //查询第k个数
{
int u = root;
while (u)
{
pushdown(u);
if (tr[tr[u].s[0]].size >= k) u = tr[u].s[0];
else if (tr[tr[u].s[0]].size + 1 == k) return u;
else k -= tr[tr[u].s[0]].size + 1, u = tr[u].s[1];
}
}
inl int build(int l,int r,int p) //建造子树
{
int mid = l + r >> 1;
int u = nodes[tt -- ];
tr[u].init(w[mid], p);
if (l < mid) tr[u].s[0] = build(l, mid - 1, u);
if (mid < r) tr[u].s[1] = build(mid + 1, r, u);
pushup(u);
return u;
}
inl void dfs(int u) //delete 操作
{
if(tr[u].s[0]) dfs(tr[u].s[0]);
if(tr[u].s[1]) dfs(tr[u].s[1]);
nodes[ ++ tt] = u; //垃圾回收
}
int main(void)
{
for(int i = 1;i < N;i ++) nodes[ ++ tt] = i;
//nit [1,n] -> 垃圾回收站
scanf("%d%d",&n,&m);
tr[0].ms = -INF;
w[0] = w[n+1] = -INF;
for(int i = 1;i <= n;i ++) scanf("%d",&w[i]);
root = build(0,n + 1,0);
char op[20];
while (m -- )
{
scanf("%s", op);
if (!strcmp(op, "INSERT"))
{
int posi, tot;
scanf("%d%d", &posi, &tot);
for (int i = 0; i < tot; i ++ ) scanf("%d", &w[i]);
int l = get_k(posi + 1), r = get_k(posi + 2);
splay(l, 0), splay(r, l);
int u = build(0, tot - 1, r);
tr[r].s[0] = u;
pushup(r), pushup(l);
}
else if (!strcmp(op, "DELETE"))
{
int posi, tot;
scanf("%d%d", &posi, &tot);
int l = get_k(posi), r = get_k(posi + tot + 1);
splay(l, 0), splay(r, l);
dfs(tr[r].s[0]);
tr[r].s[0] = 0;
pushup(r), pushup(l);
}
else if (!strcmp(op, "MAKE-SAME"))
{
int posi, tot, c;
scanf("%d%d%d", &posi, &tot, &c);
int l = get_k(posi), r = get_k(posi + tot + 1);
splay(l, 0), splay(r, l);
auto& son = tr[tr[r].s[0]];
son.same = 1, son.v = c, son.sum = c * son.size;
if (c > 0) son.ms = son.ls = son.rs = son.sum;
else son.ms = c, son.ls = son.rs = 0;
pushup(r), pushup(l);
}
else if (!strcmp(op, "REVERSE"))
{
int posi, tot;
scanf("%d%d", &posi, &tot);
int l = get_k(posi), r = get_k(posi + tot + 1);
splay(l, 0), splay(r, l);
auto& son = tr[tr[r].s[0]];
son.rev ^= 1;
swap(son.ls, son.rs);
swap(son.s[0], son.s[1]);
pushup(r), pushup(l);
}
else if (!strcmp(op, "GET-SUM"))
{
int posi, tot;
scanf("%d%d", &posi, &tot);
int l = get_k(posi), r = get_k(posi + tot + 1);
splay(l, 0), splay(r, l);
printf("%d\n", tr[tr[r].s[0]].sum);
}
else printf("%d\n", tr[root].ms); //MAX-SUM
}
return 0;
}
/*
输入样例 1
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-SUM
*/
可能对于刚刚学习splay的人来说，这道题明显有点难了
点这里，来做P3224 [HNOI2012] 永无乡答案我放在这里了，这道题维护的是数字的val
这道题用了并查集的启发式合并，说白了就是在合并操作中将较小的集合合并到较大的集合中，以减少所浪费的时间
为什么要用启发式合并？合并操作不是O(1)吗？
不不不，这道题是并查集维护每个splay，splay的合并是O(log n)，并不是O(1)，需要启发式合并，来过毒瘤数据
#include"bits/stdc++.h"
using namespace std;
const int N = 500010;
#define inl inline
#define reg register
//#define ll long long
int n,m;
struct node
{
int s[2],p,v,id;
int size;
inl void init(int _v,int _id, int _p)
{
v = _v,id = _id,p = _p;
size = 1;
}
}tr[N];
int root[N],idx;
int p[N];
inl void read()
{
std::cin.tie(nullptr);
}
inl int Find(int x)
{
return p[x] != x ? p[x] = Find(p[x]) : p[x];
}
inl void pushup(int x)
{
tr[x].size = tr[tr[x].s[0]].size + tr[tr[x].s[1]].size + 1;
}
inl void rotate(int x)
{ //y为x的父节点，z为x的爷节点
int y = tr[x].p,z = tr[y].p;
int k = tr[y].s[1] == x;//k为（x是否为y的右节点）//即k为（x节点的左右儿子）
tr[z].s[tr[z].s[1] == y] = x,tr[x].p = z;
//z节点的y儿子改为x儿子，x节点的父节点改为z
tr[y].s[k] = tr[x].s[k ^ 1],tr[tr[x].s[k ^ 1]].p = y;
//处理原x的右儿子，以及原x右节点的parent
tr[x].s[k ^ 1] = y,tr[y].p = x;
//更改原x的非y儿子节点（另一个儿子），更改y的父节点为x
pushup(y),pushup(x);
//update size
//x上移1个单位
}
inl void splay(int x,int k,int b)//将集合b的splay中x节点转到k节点的下面while(tr[x].p != k)
{
int y = tr[x].p, z = tr[y].p;
if(z != k)
if((tr[y].s[1] == x) ^ (tr[z].s[1] == y)) rotate(x);
else rotate(y);
//双旋
rotate(x);
}
//k==0
if(!k) root[b] = x;//集合b的根节点为x
}
inl void insert(int v,int id,int b)//将编号为id，重要度为v 的节点加入集合b的splay中
{
reg int u = root[b],p = 0;
while(u) p = u,u = tr[u].s[v > tr[u].v];
u = ++idx;
if(p) tr[p].s[v > tr[p].v] = u;
tr[u].init(v,id,p);
splay(u,0,b);
}
inl void dfs(int u,int b)//将根节点u所在splay中的每一个点插入到集合b的splay中
{
if(tr[u].s[0]) dfs(tr[u].s[0],b);
if(tr[u].s[1]) dfs(tr[u].s[1],b);
insert(tr[u].v,tr[u].id,b);//查询集合b的splay中重要度第k小的节点编号
}
inl int get_k(int k,int b)//²éѯ¼¯ºÏbµÄSplayÖÐÖØÒª¶ÈµÚkСµÄ½Úµã±àºÅ
{
int u = root[b];
while(u)
{
if(tr[tr[u].s[0]].size >= k) u = tr[u].s[0];
else if(tr[tr[u].s[0]].size + 1 == k) return tr[u].id;
else k -= tr[tr[u].s[0]].size + 1,u = tr[u].s[1];
}
return -1;
}
int main(void)
{
read();
scanf("%d%d",&n,&m);
//init Find-Union and root
for(int i = 1;i <= n;i ++)
{
p[i] = root[i] = i;
int v;
scanf("%d",&v);
tr[i].init(v,i,0);/init 每个集合的root
}
idx = n;//前n个下标个n个splay的根节点用
while(m--)
{
int a,b;
scanf("%d%d",&a,&b);
a = Find(a),b = Find(b);
if(a != b)//如果两个岛不在一个集合中，需要合并
{
/*
tr[root[a]].size > tr[root[b]].size
保证集合a中元素的个数 <= 集合b中元素的个数
启发式合并
保证较小的集合加入较大的集合
*/
if(tr[root[a]].size > tr[root[b]].size)
swap(a,b);//保证集合a中的元素个数 <= 集合b中的元素个数
dfs(root[a],b);//将集合a的splay里的每一个点插入到集合b的splay里面
p[a] = b;//将集合a合并入集合b
}
}
reg int q;
scanf("%d",&q);
while(q --)
{
char op[2];
int a,b;
scanf("%s%d%d",op,&a,&b);
if(*op == 'B')//add edge
{
a = Find(a),b = Find(b);
if(a != b)//Union 如果两个岛不在一个集合里，需要合并
{
if(tr[root[a]].size > tr[root[b]].size)
swap(a,b);
dfs(root[a],b);
p[a] = b;
}
}else
{
a = Find(a);//集合中不足b个数，输出"-1"
if(tr[root[a]].size < b) puts("-1");
else printf("%d\n",get_k(b,a));//否则查询第k小数
}
}
return 0;
}
好了，就到这里了
数据结构不能单纯靠记忆，一定要理解，记住啊，一定要靠理解，记忆只不过是帮助你在考场上调试出来的东西，并不是其主导的因素
标签：知识点,inl,int,tr,splay,例题,节点,size From： https://www.cnblogs.com/better-coding/p/17774921.html