BZOJ 3224: Tyvj 1728 普通平衡树

3224: Tyvj 1728 普通平衡树

Time Limit: 10 Sec Memory Limit: 128 MB
Submit: 9275 Solved: 3932
[Submit][Status][Discuss]

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.每个数的数据范围：[-1e7,1e7]

数据如下http://pan.baidu.com/s/1jHMJwO2

Source

平衡树

[Submit][Status][Discuss]

小生的第二道平衡树板子题。

#include <bits/stdc++.h>

const int inf = 2e9 + 9;

class Splay {
public:
Splay(void) {
root = NULL;
for (top = 0; top < siz; ++top)
stk[top] = tree + top;
}

inline void insert(int val) {
if (find(val) != NULL)
++root->count, update(root);
else if (root == NULL)
root = newnode(val, NULL);
else
splay(insert(root, val), NULL);
}

inline void erase(int val) {
if (find(val) != NULL)
erase(root, 1);
}

inline int rnk(int val) {
if (find(val) != NULL)
return size(root->son[0]) + 1;
else
return 0;
}

inline int qry(int kth) {
if (size(root) < kth)
return 0;
for (node *t = root; t; ) {
if (kth > size(t->son[0])) {
kth -= size(t->son[0]);
if (kth >= 1 && kth <= t->count)
return t->value;
else
kth -= t->count, t = t->son[1];
}
else
t = t->son[0];
}
}

inline int prv(int val) {
int ret = -inf;
for (node *t = root; t; ) {
if (t->value < val)
if (ret < t->value)
ret = t->value;
t = t->son[val > t->value];
}
return ret;
}

inline int nxt(int val) {
int ret = inf;
for (node *t = root; t; ) {
if (t->value > val)
if (ret > t->value)
ret = t->value;
t = t->son[val >= t->value];
}
return ret;
}

private:
struct node {
int size;
int value;
int count;
node *father;
node *son[2];
}*root;

const static int siz = 1e5 + 5;

node tree[siz], *stk[siz]; int top;

inline node *newnode(int v, node *f) {
node *t = stk[--top];
t->size = 1;
t->value = v;
t->count = 1;
t->father = f;
t->son[0] = NULL;
t->son[1] = NULL;
return t;
}

inline void freenode(node *t) {
stk[top++] = t;
}

inline int size(node *t) {
return t == NULL ? 0 : t->size;
}

inline void update(node *t) {
if (t != NULL) {
t->size = t->count;
t->size += size(t->son[0]);
t->size += size(t->son[1]);
}
}

inline bool son(node *f, node *s) {
if (f == NULL)
return 0;
return f->son[1] == s;
}

inline void connect(node *f, node *s, bool k) {
if (f != NULL)
f->son[k] = s;
else
root = s;
if (s != NULL)
s->father = f;
}

inline void rotate(node *t) {
node *f = t->father;
node *g = f->father;
bool a = son(f, t), b = !a;
connect(f, t->son[b], a);
connect(g, t, son(g, f));
connect(t, f, b);
update(f);
update(t);
}

inline void splay(node *t, node *p) {if (t) {
while (t->father != p) {
node *f = t->father;
node *g = f->father;
if (g == p)
rotate(t);
else {
if (son(g, f) ^ son(f, t))
rotate(t), rotate(t);
else
rotate(f), rotate(t);
}
}
}
}

inline node *find(int val) {
node *ret = root;
while (ret != NULL && ret->value != val)
ret = ret->son[val >= ret->value];
return splay(ret, NULL), ret;
}

node *insert(node *t, int val) {
node *ret = t->son[val >= t->value];
if (ret == NULL)
ret = t->son[val >= t->value] = newnode(val, t);
else
ret = insert(ret, val);
return update(t), ret;
}

inline void erase(node *t) {
if (t->son[0] == NULL)
connect(NULL, t->son[1], 0), update(root);
else if (t->son[1] == NULL)
connect(NULL, t->son[0], 0), update(root);
else {
node *p = t->son[0];
while (p->son[1] != NULL)
p = p->son[1];
splay(p, t);
connect(NULL, p, 0);
connect(p, t->son[1], 1);
update(root);
}
freenode(t);
}

inline void erase(node *t, int k) {
t->count -= k;
if (t->count <= 0)
erase(t);
else
update(t);
}
}S;

inline int next(void) {
int ret = 0;
int neg = false;
int bit = getchar();
while (bit <= '0') {
if (bit == '-')
neg ^= true;
bit = getchar();
}
while (bit >= '0') {
ret = ret*10 + bit - '0';
bit = getchar();
}
return neg ? -ret : ret;
}

signed main(void) {
for (int n = next(); n--; ) {
int opt = next();
int num = next();
if (opt == 1)
S.insert(num);
else if (opt == 2)
S.erase(num);
else if (opt == 3)
printf("%d\n", S.rnk(num));
else if (opt == 4)
printf("%d\n", S.qry(num));
else if (opt == 5)
printf("%d\n", S.prv(num));
else
printf("%d\n", S.nxt(num));
}
}

@Author: YouSiki