splay + 垃圾回收 知识点与例题的简要讲解
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; }
好了，就到这里了
数据结构不能单纯靠记忆，一定要理解，记住啊，一定要靠理解，记忆只不过是帮助你在考场上调试出来的东西，并不是其主导的因素
