splay模板

最新推荐文章于 2021-02-09 21:03:02 发布
最新推荐文章于 2021-02-09 21:03:02 发布
阅读量221 收藏
点赞数
分类专栏： 算法模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KIKO_caoyue/article/details/86536922
版权

代码来自洛谷日报，感谢洛谷
本篇文章没有splay的教学，只有代码的使用说明。

直接贴上代码：
这个不带reverse的模板

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 2e5+7;
int n, op, x;
int ch[maxn][2], fa[maxn], val[maxn], cnt[maxn], siz[maxn], ncnt, root;
bool chk(int x) 
{
    return ch[fa[x]][1]==x;
}
void pushup(int x) 
{
    siz[x] = siz[ch[x][0]] + siz[ch[x][1]] + cnt[x];
}
void rotate(int x) 
{
    int y = fa[x], z = fa[y], k = chk(x), w = ch[x][k^1];
    ch[y][k] = w; 
	fa[w] = y;
    ch[z][chk(y)] = x;
	fa[x] = z;
    ch[x][k^1] = y; 
	fa[y] = x;
    pushup(y); 
	pushup(x);
}
void splay(int x, int goal = 0) 
{
    while(fa[x] != goal) 
	{
        int y = fa[x], z = fa[y];
        if (z != goal) 
		{
            if(chk(x) == chk(y)) rotate(y);
            else rotate(x);
        }
        rotate(x);
    }
    if(!goal) root = x;
}
void insert(int x) 
{
    int cur = root, p = 0;
    while(cur && val[cur] != x) 
	{
        p = cur;
        cur = ch[cur][x > val[cur]];
    }
    if(cur) cnt[cur]++;
	else 
	{
        cur = ++ncnt;
        if(p) ch[p][x > val[p]] = cur;
        ch[cur][0] = ch[cur][1] = 0;
        fa[cur] = p; 
		val[cur] = x;
        cnt[cur] = siz[cur] = 1;
    }
    splay(cur);
}
void find(int x) 
{
    int cur = root;
    while(ch[cur][x > val[cur]] && x != val[cur]) 
	{
        cur = ch[cur][x > val[cur]];
    }
    splay(cur);
}
int kth(int k) 
{
    int cur = root;
    while(true) 
	{
        if(ch[cur][0] && k <= siz[ch[cur][0]]) 
		{
            cur = ch[cur][0];
        } 
		else if(k > siz[ch[cur][0]] + cnt[cur]) 
		{
            k -= siz[ch[cur][0]] + cnt[cur];
            cur = ch[cur][1];
        } 
		else 
		{
            return cur;
        }
    }
}
int pre(int x) 
{
    find(x);
    if(val[root] < x) return root;
    int cur = ch[root][0];
    while(ch[cur][1]) cur = ch[cur][1];
    return cur;
}

int succ(int x) 
{
    find(x);
    if (val[root] > x) return root;
    int cur = ch[root][1];
    while(ch[cur][0]) cur = ch[cur][0];
    return cur;
}

void remove(int x) 
{
    int last = pre(x), next = succ(x);
    splay(last); 
	splay(next, last);
    int del = ch[next][0];
    if(cnt[del] > 1) 
	{
        cnt[del]--;
        splay(del);
    }
    else ch[next][0] = 0;
}
int main() 
{
    scanf("%d", &n);
    insert(INF);
    insert(-INF);
    while(n--) 
	{
        scanf("%d%d", &op, &x);
        switch (op) 
		{
            case 1: insert(x); break;
            case 2: remove(x); break;
            case 3: find(x); printf("%d\n", siz[ch[root][0]]); break;
            case 4: printf("%d\n", val[kth(x+1)]); break;
            case 5: printf("%d\n", val[pre(x)]); break;
            case 6: printf("%d\n", val[succ(x)]); break;
        }
    }
}

  • insert(x)，插入x

  • remove(x)，删除x(若有多个相同的，只删除一个)

  • find(x)，将x伸展到根，则siz[ch[root][0]]就是x左子树的大小，即x的排名

  • kth(x+1)，查询排名为x的数，val[kth(x+1)]为排名为x的数的值

  • pre(x)，查询x的前驱，前驱定义为小于xx，且最大的数

  • succ(x)，查询x的后继，后继定义为大于xx，且最小的数

这个是带reverse的模板：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5+7;
int ch[maxn][2], fa[maxn], val[maxn], cnt[maxn], siz[maxn], rev[maxn], root, ncnt;
int n, m, x, y;
bool chk(int x) 
{
    return ch[fa[x]][1] == x;
}
void pushup(int x) 
{
    siz[x] = siz[ch[x][0]] + siz[ch[x][1]] + cnt[x];
}
void pushdown(int x) 
{
    if(rev[x])  
	{
        swap(ch[x][0], ch[x][1]);
        rev[ch[x][0]] ^= 1;
        rev[ch[x][1]] ^= 1;
        rev[x] = 0;
    }
}
void rotate(int x) 
{
    int y = fa[x], z = fa[y], k = chk(x), w = ch[x][k^1];
    ch[y][k] = w; 
	fa[w] = y;
    ch[z][chk(y)] = x; 
	fa[x] = z;
    ch[x][k^1] = y; 
	fa[y] = x;
    pushup(y); 
	pushup(x); 
}
void splay(int x, int goal = 0) 
{
    while(fa[x] != goal) 
	{
        int y = fa[x], z = fa[y];
        if(z != goal) 
		{
            if(chk(x) == chk(y)) rotate(y);
            else rotate(x);
        }
        rotate(x);
    }
    if(!goal) root = x;
}
void insert(int x) 
{
    int cur = root, p = 0;
    while(cur && val[cur] != x) 
	{
        p = cur;
        cur = ch[cur][x > val[cur]];
    }
    if(cur) cnt[cur]++;
	else 
	{
        cur = ++ncnt;
        if(p) ch[p][x > val[p]] = cur;
        ch[cur][0] = ch[cur][1] = 0;
        fa[cur] = p; 
		val[cur] = x;
        cnt[cur] = siz[cur] = 1;
    }
    splay(cur);
}
void find(int x) 
{
    int cur = root;
    while(ch[cur][x > val[cur]] && val[cur] != x) 
	{
        cur = ch[cur][x > val[cur]];
    }
    splay(cur);
}
int kth(int k) 
{
    int cur = root;
    while (true) 
	{
        pushdown(cur);
        if (ch[cur][0] && k <= siz[ch[cur][0]]) 
		{
            cur = ch[cur][0];
        } 
		else if (k > siz[ch[cur][0]] + cnt[cur]) 
		{
            k -= siz[ch[cur][0]] + cnt[cur];
            cur = ch[cur][1];
        } 
		else 
		{
            return cur;
        }
    }
}
void reverse(int l, int r) 
{
    int x = kth(l), y = kth(r+2);
    splay(x); 
	splay(y, x);
    rev[ch[y][0]] ^= 1;
}
int pre(int x) 
{
    find(x);
    if(val[root] < x) return root;
    int cur = ch[root][0];
    while(ch[cur][1]) cur = ch[cur][1];
    return cur;
}
int succ(int x) 
{
    find(x);
    if(val[root] > x) return root;
    int cur = ch[root][1];
    while(ch[cur][0]) cur = ch[cur][0];
    return cur;
}
void output(int x) 
{
    pushdown(x);
    if(ch[x][0]) output(ch[x][0]);
    if(val[x] && val[x] <= n) printf("%d ", val[x]);
    if(ch[x][1]) output(ch[x][1]);
}
int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i <= n+1; i++) insert(i);
    while (m--) 
	{
        scanf("%d%d", &x, &y);
        reverse(x, y);
    }
    output(root);
    return 0;
}
  • reverse(l,r)，区间[l,r]翻转
  • output(x)，从根x开始中序遍历，输出splay tree上的所有数

下面这个是splay维护区间树：

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 1e6+7;
int n, m, arr[maxn], c, x, y, z;
char buf[32];
int siz[maxn], sum[maxn], upd[maxn], rev[maxn], la[maxn], ra[maxn], gss[maxn];
int val[maxn], ch[maxn][2], fa[maxn], ncnt, root;
queue<int> q;
void recycle(int x) 
{
    if (ch[x][0]) recycle(ch[x][0]);
    if (ch[x][1]) recycle(ch[x][1]);
    q.push(x);
}
inline int newNode(int x) 
{
    int cur;
    if (q.empty()) cur = ++ncnt;
    else cur = q.front(), q.pop();
    ch[cur][0] = ch[cur][1] = fa[cur] = 0;
    val[cur] = sum[cur] = gss[cur] = x;
    la[cur] = ra[cur] = max(0, x);
    upd[cur] = rev[cur] = 0;
    siz[cur] = 1;
    return cur;
}
inline bool chk(int x) 
{
    return ch[fa[x]][1] == x;
}
inline void pushup(int x) 
{
    int l = ch[x][0], r = ch[x][1];
    siz[x] = siz[l] + siz[r] + 1;
    sum[x] = sum[l] + sum[r] + val[x];
    // 这里和线段树不同，线段树只有叶子上有权值，平衡树上所有点都有，必须+val[x] 
    la[x] = max(la[l], sum[l] + val[x] + la[r]);
    ra[x] = max(ra[r], sum[r] + val[x] + ra[l]);
    gss[x] = max(ra[l] + val[x] + la[r], max(gss[l], gss[r]));
}

inline void rotate(int x) 
{
    int y = fa[x], z = fa[y], k = chk(x), w = ch[x][k^1];
    ch[y][k] = w; 
	fa[w] = y;
    ch[z][chk(y)] = x; 
	fa[x] = z;
    ch[x][k^1] = y; 
	fa[y] = x;
    pushup(y); 
	pushup(x);
}
inline void pushdown(int x) 
{
    int l = ch[x][0], r = ch[x][1];
    if(upd[x]) 
	{
        upd[x] = rev[x] = 0;
        if(l) 
		{
            upd[l] = 1; 
			val[l] = val[x];
            sum[l] = val[x] * siz[l];
            la[l] = ra[l] = max(sum[l], 0);
            gss[l] = val[x] < 0 ? val[x] : sum[l];
        }
        if(r) 
		{
            upd[r] = 1; 
			val[r] = val[x];
            sum[r] = val[x] * siz[r];
            la[r] = ra[r] = max(sum[r], 0);
            gss[r] = val[x] < 0 ? val[x] : sum[r];
        }
    }
    if(rev[x]) 
	{
        rev[l] ^= 1; 
		rev[r] ^= 1; 
		rev[x] = 0;
        swap(la[l], ra[l]); 
		swap(la[r], ra[r]);
        swap(ch[l][0], ch[l][1]);
        swap(ch[r][0], ch[r][1]);
    }
}
inline void splay(int x, int goal = 0) 
{
    while(fa[x] != goal) {
        int y = fa[x], z = fa[y];
        if (z != goal) 
		{
            if (chk(x) == chk(y)) rotate(y);
            else rotate(x);
        }
        rotate(x);
    }
    if (!goal) root = x;
}
int build(int l, int r, int *arr) 
{
    if (l > r) return 0;
    int mid = (l+r)>>1, cur = newNode(arr[mid]);
    if (l == r) return cur;
    if ((ch[cur][0] = build(l, mid-1, arr))) fa[ch[cur][0]] = cur;
    if ((ch[cur][1] = build(mid+1, r, arr))) fa[ch[cur][1]] = cur;
    pushup(cur);
    return cur;
}
inline int kth(int k) 
{
    int cur = root;
    while(true) 
	{
        pushdown(cur);
        if(ch[cur][0] && k <= siz[ch[cur][0]]) 
		{
            cur = ch[cur][0];
        } 
		else if (k > siz[ch[cur][0]] + 1) {
            k -= siz[ch[cur][0]] + 1;
            cur = ch[cur][1];
        } 
		else 
		{
            return cur;
        }
    }
}
inline void insert(int x, int y) 
{
    int u = kth(x+1), v = kth(x+2);
    splay(u); 
	splay(v, u);
    ch[v][0] = y; 
	fa[y] = v;
    pushup(v); 
	pushup(u); 
}
inline int qsum(int x, int y) 
{
    int u = kth(x), v = kth(x+y+1);
    splay(u); 
	splay(v, u);
    return sum[ch[v][0]];
}

inline int qgss() 
{
    return gss[root];
}
inline void remove(int x, int y) 
{
    int u = kth(x), v = kth(x+y+1);
    splay(u); 
	splay(v, u);
    recycle(ch[v][0]);
    ch[v][0] = 0;
    pushup(v); 
	pushup(u);
}

inline void reverse(int x, int y) 
{
    int u = kth(x), v = kth(x+y+1);
    splay(u); 
	splay(v, u);
    int w = ch[v][0];
    if (!upd[w]) 
	{
        rev[w] ^= 1;
        swap(ch[w][0], ch[w][1]);
        swap(la[w], ra[w]);
        pushup(v); 
		pushup(u);
    }
}
inline void update(int x, int y, int z) 
{
    int u = kth(x), v = kth(x+y+1);
    splay(u); 
	splay(v, u);
    int w = ch[v][0];
    upd[w] = 1; 
	val[w] = z; 
	sum[w] = siz[w] * z;
    la[w] = ra[w] = max(0, sum[w]);
    gss[w] = z < 0 ? z : sum[w];
    pushup(v); 
	pushup(u);
}
int main() {
    scanf("%d%d", &n, &m);
    for (int i = 2; i <= n+1; i++)
	{
        scanf("%d", arr+i);
    }
    gss[0] = val[0] = -INF;
    arr[1] = arr[n += 2] = -INF;
    build(1, n, arr); 
	root = 1;
    while (m--) 
	{
        scanf("%s", buf);
        switch ((buf[2] + buf[1]) ^ *buf) 
		{
            case 'G'^('E'+'T'):
                scanf("%d%d", &x, &y);
                printf("%d\n", qsum(x, y));
                break;
            case 'M'^('A'+'X'):
                printf("%d\n", qgss());
                break;
            case 'R'^('E'+'V'):
                scanf("%d%d", &x, &y);
                reverse(x, y);
                break;
            case 'M'^('A'+'K'):
                scanf("%d%d%d", &x, &y, &z);
                update(x, y, z);
                break;
            case 'D'^('E'+'L'):
                scanf("%d%d", &x, &y);
                remove(x, y);
                break;
            case 'I'^('N'+'S'):
                scanf("%d%d", &x, &y);
                memset(arr, 0, sizeof arr);
                for (int i = 1; i <= y; i++) 
                {
                    scanf("%d", arr+i);
                }
                insert(x, build(1, y, arr));
                break;
        }
    }
    return 0;
}

其中qgss()为求序列中最大子段和

ACgay_caoyue
关注
专栏目录
splay模板（功能最全）
huzujun的博客
08-03 3767
回想起来splay大概是高中时的噩梦吧，手敲splay的确挑战太大了，不过到了acm时期，其实应该是不用惧怕splay的，把板子准备好就问题不大。 poj3580 虽然不是最简单的题，但是可以作为板子题 https://vjudge.net/problem/POJ-3580 题目大意： 要求实现一种数据结构，支持对一个数字序列的 6 种操作： ADD x y val：第 x...
Splay模板 Splay题型大荟萃
snowy_smile的博客
01-21 809
以HDU4453为例，整理了一些Splay的题型 /* 【算法介绍】 Splay叫做伸展树，是一种二叉搜索树，也可以说是一种平衡树结构。 其可以维护节点的左右次序值，也就是说，我们在Splay上做中序遍历的次序输出节点，得到的便是所有节点的左右次序。 【数据结构】 int ch[N][2], fa[N]; //节点的链接关系 int num[N], sz[N]; //节点个数与子树大小 1
splay 模板
09-05
splay经典代码,hdu1890,经典入门题,可作为模板
Splay模板
dk810510的博客
01-07 86
打LCT的时候发现Splay很不熟, 因此这里贴一下模板 洛谷P3369 https://www.luogu.org/problem/show?pid=3369#sub /* 提一些要注意的点: 1. 注意判断边界, 不要访问到空节点 2. 每一次操作或访问完以后, 记得要splay到root 3. insert操作只要update当前节点和父亲节点即可, ...
SplayBZOJ1208
qq_36876305的博客
01-11 200
题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=1208 #include using namespace std; const int N = 1E5 + 7, MOD = 1000000; int size[N], cnt[N], key[N], ch[N][2], f[N]; int sz, rt; void c
splay模板基本操作
Hunter_HunterL的博客
08-04 410
Splay模板指针实现 splay中序遍历维护原序列下标的顺序，翻转后这个顺序会改变，但是splay中第x个数代表变换后序列中第x个数 这样就可以直接查找变换后的序列 重在代码 文艺平衡树 #include #include #include #include #define INF 0x3f3f3f3f using namespace std; struct node { no
Luogu P2234营业额统计（Splay模板题）
稚始稚终的博客
02-09 230
P2234 [HNOI2002]营业额统计 AC Code #include<bits/stdc++.h> using namespace std; const int N=5e4+10; int root,tot; struct splay_tree { int ff,cnt,ch[2],val,size; }tr[N]; void update(int x) { tr[x].size=tr[tr[x].ch[0]].size+tr[tr[x].ch[1]].size+tr[
Splay 模板
Object_的博客
03-08 169
模板题：https://www.luogu.org/problemnew/show/P3391 #include&lt;bits/stdc++.h&gt; using namespace std; const int N=100005; int ch[N][2],par[N],val[N],cnt[N],size[N],rev[N],root,ncnt; int n,m,x,y; bool c...
Splay（伸展树）模板
01-10
Splay模板包括旋转，主函数Splay，插入，删除，最大值，最小值，查询k大，查询排名
splay【模板】
wpx18182323的博客
08-14 1387
题目描述 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 插入 x 数 删除 x 数(若有多个相同的数，因只删除一个) 查询 x 数的排名(排名定义为比当前数小的数的个数 +1+1 。若有多个相同的数，因输出最小的排名) 查询排名为 x 的数 求 x 的前驱(前驱定义为小于 x ，且最大的数) 求 x 的后继(后继定义为大于 x ，且最小的数) 输入输...
【Splay模板】
CJ_HYJ的博客
11-14 330
SplaySplay：其实是个十分神奇的东西——具体来说呢，就是二叉搜索树的优化，使得它的最坏情况(一条链)消除再具体一点呢。。。百度百科这里推荐yyb神犇的博客yyb神犇的博客，因为笔者觉得他的博客是我见过博客中写的比较清晰的，常数也是很小的，且笔者也是在他博客中弄懂SplaySplay的，希望大家能够有所收获。 Tips:完整代码可以在我这篇文章里看，还有打完板子之后可以在这里评测。在此附上完
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值