BZOJ 3224: Tyvj 1728 普通平衡树

Description

您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：

1. 插入x数

2. 删除x数(若有多个相同的数，因只删除一个)

3. 查询x数的排名(若有多个相同的数，因输出最小的排名)

4. 查询排名为x的数

5. 求x的前驱(前驱定义为小于x，且最大的数)

6. 求x的后继(后继定义为大于x，且最小的数)

Input

第一行为n，表示操作的个数,下面n行每行有两个数opt和x，opt表示操作的序号(1<=opt<=6)

Output

对于操作3,4,5,6每行输出一个数，表示对应答案

Sample Input

10

1 106465

4 1

1 317721

1 460929

1 644985

1 84185

1 89851

6 81968

1 492737

5 493598

Sample Output

106465

84185

492737

HINT

1.n的数据范围：n<=100000

2.每个数的数据范围：[-2e9,2e9]

分析

就是学splay模板而已，但我感觉常数好大，之后慢慢改改

代码

#include <bits/stdc++.h>

#define N 500000

struct
{
int fa;
int son[3];
int size[3];
int count;
int cover;
}t
;

int n;
int node;
int root;

void rotate(int x,int w)
{
int f = t[x].fa;
int g = t[f].fa;
t[f].son[3 - w] = t[x].son[w];
if (t[x].son[w])
t[t[x].son[w]].fa = f;
t[x].fa = g;
t[f].size[3 - w] = t[x].size[w];
t[x].size[w] += t[f].size[w] + 1;
if (g)
{
if (f == t[g].son[1])
t[g].son[1] = x;
else t[g].son[2] = x;
}
t[f].fa = x;
t[x].son[w] = f;
}

void splay(int x)
{
int y;
while (t[x].fa)
{
y = t[x].fa;
if (!t[y].fa)
{
if (x == t[y].son[1])
rotate(x,2);
else rotate(x,1);
continue;
}
if (y == t[t[y].fa].son[1])
{
if (x == t[y].son[1])
rotate(y,2), rotate(x,2);
else rotate(x,1), rotate(x,2);
}
else
{
if (x == t[y].son[2])
rotate(y,1), rotate(x,1);
else rotate(x,2), rotate(x,1);
}
}
root = x;
}

void insert(int x,int add)
{
if (t[x].cover >= add)
{
if (!t[x].son[1])
{
t[x].son[1] = ++node;
t[node].cover = add;
t[node].fa = x;
if (!root)
root = node;
}
else insert(t[x].son[1],add);
t[x].size[1]++;
}
else
{
if (!t[x].son[2])
{
t[x].son[2] = ++node;
t[node].cover = add;
t[node].fa = x;
if (!root)
root = node;
}
else insert(t[x].son[2],add);
t[x].size[2]++;
}
}

void del(int x,int dec)
{
if (!x)
return;
if (dec == t[x].cover)
{
splay(x);

if (!t[x].son[1] && !t[x].son[2])
{
root = 0;
return;
}

if (!t[x].son[1])
{
root = t[x].son[2];
t[t[x].son[2]].fa = 0;
return;
}

if (!t[x].son[2])
{
root = t[x].son[1];
t[t[x].son[1]].fa = 0;
return;
}

int f = t[x].son[1];
int tmp = t[x].son[2];
while (t[f].son[2])
f = t[f].son[2];
splay(f);
t[f].son[2] = tmp;
t[tmp].fa = f;
return;
}
if (dec < t[x].cover)
del(t[x].son[1],dec);
else del(t[x].son[2],dec);
}

int kth(int x,int add,int now)
{
insert(root,add);
splay(node);
int ans = t[node].size[1] + 1;
del(node,add);
return ans;
}

int findK(int x,int k)
{
if (k == t[x].size[1] + 1)
return t[x].cover;
if (k <= t[x].size[1])
return findK(t[x].son[1],k);
else return findK(t[x].son[2],k - t[x].size[1] - 1);
}

bool flag;

int pred(int x,int k)
{
int f = t[x].son[1];
if (!f)
return 0;
while (t[f].son[2])
f = t[f].son[2];
if (t[f].cover != k)
flag = 1;
return f;
}

int succ(int x,int k)
{
int f = t[x].son[2];
if (!f)
return 0;
while (t[f].son[1])
f = t[f].son[1];
if (t[f].cover != k)
flag = 1;
return f;
}

int main()
{
int n;
scanf("%d",&n);
for (int i = 1; i <= n; i++)
{
int opt,x;
scanf("%d%d",&opt,&x);
if (opt == 1)
insert(root,x), splay(node);
if (opt == 2)
del(root,x);
if (opt == 3)
printf("%d\n",kth(root,x,0));
if (opt == 4)
printf("%d\n",findK(root,x));
if (opt == 5)
{
int ans;
insert(root,x);
splay(node);
for (flag = 0, ans = pred(root,x); !flag || !ans; splay(ans), ans = pred(root,x));
del(root,x);
printf("%d\n",t[ans].cover);
}
if (opt == 6)
{
int ans;
insert(root,x);
splay(node);
for (flag = 0, ans = succ(root,x); !flag || !ans; splay(ans), ans = succ(root,x));
del(root,x);
printf("%d\n",t[ans].cover);
}
}
}