[ZJOI2006]书架（平衡树）

发表于 分类于 ，
ZJOI2006书架

题目

描述

小T有一个很大的书柜。这个书柜的构造有些独特，即书柜里的书是从上至下堆放成一列。她用$1$到$n$的正整数给每本书都编了号。
小T在看书的时候，每次取出一本书，看完后放回书柜然后再拿下一本。由于这些书太有吸引力了，所以她看完后常常会忘记原来是放在书柜的什么位置。不过小T的记忆力是非常好的，所以每次放书的时候至少能够将那本书放在拿出来时的位置附近，比如说她拿的时候这本书上面有$X$本书，那么放回去时这本书上面就只可能有$X-1$、$X$或$X+1$本书。
当然也有特殊情况，比如在看书的时候突然电话响了或者有朋友来访。这时候粗心的小T会随手把书放在书柜里所有书的最上面或者最下面，然后转身离开。
久而久之，小T的书柜里的书的顺序就会越来越乱，找到特定的编号的书就变得越来越困难。于是她想请你帮她编写一个图书管理程序，处理她看书时的一些操作，以及回答她的两个提问：(1)编号为$X$的书在书柜的什么位置；(2)从上到下第$i$本书的编号是多少。

输入

第一行有两个数$n,m$，分别表示书的个数以及命令的条数；第二行为$n$个正整数：第$i$个数表示初始时从上至下第$i$个位置放置的书的编号；第三行到$m+2$行，每行一条命令。命令有5种形式：
1．Top S——表示把编号为$S$的书放在最上面。
2． Bottom S——表示把编号为$S$的书放在最下面。
3． Insert S T——$T∈{-1,0,1}$，若编号为$S$的书上面有$X$本书，则这条命令表示把这本书放回去后它的上面有$X+T$本书；
4． Ask S——询问编号为$S$的书的上面目前有多少本书。
5． Query S——询问从上面数起的第$S$本书的编号。

输出

对于每一条Ask或Query语句你应该输出一行，一个数，代表询问的答案。

输入样例

1
2
3
4
5
6
7
8
9
10
11
12
10 10
1 3 2 7 5 8 10 4 9 6
Query 3
Top 5
Ask 6
Bottom 3
Ask 3
Top 6
Insert 4 -1
Query 5
Query 2
Ask 2

输出样例

1
2
3
4
5
6
2
9
9
7
5
3

说明

100%的数据，$n,m <= 80000$

解题思路

用平衡树可以完成这些操作：

  • Top S：将该元素旋转至根，然后将其左子树连到它的后继上
  • Bottom S：将该元素旋转至根，然后将其右子树连到它的前驱上
  • Insert S T：将该元素与其前驱或后继交换信息
  • Ask S：将该元素旋转至根，返回其左子树大小
  • Query S：在树上直接找即可

时间复杂度：$O(M\log_2N)$

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
# include<cstdio>
# include<algorithm>

using namespace std;

const int N = 80005;
int n, m, q, qt, a[N], pos[N];
char opt[10];

struct BST{
# define lson tr[x].son[0]
# define rson tr[x].son[1]
	struct Splay{
		int fa, son[2];
		int size, id;
	}tr[N];
	int root = 0, cnt = 0;
	inline int newNode(){
		cnt++;
		tr[cnt].fa = tr[cnt].son[0] = tr[cnt].son[1] = 0;
		tr[cnt].size = 1, tr[cnt].id = 0;
		return cnt;
	}
	inline void pushup(int x){
		tr[x].size = tr[lson].size + tr[rson].size + 1;
	}
	inline int build(int l, int r, int f){
		if(l > r)	return 0;
		int mid = (l + r) >> 1;
		int x = newNode();
		tr[x].id = a[mid];
		pos[a[mid]] = x;
		tr[x].fa = f;
		tr[x].son[0] = build(l, mid-1, x);
		tr[x].son[1] = build(mid+1, r, x);
		pushup(x);
		return x;
	}
	inline void rotate(int x, int kind){
		int y = tr[x].fa, z = tr[y].fa, B = tr[x].son[kind];
		tr[x].son[kind] = y, tr[y].son[!kind] = B, tr[z].son[tr[z].son[1] == y] = x;
		tr[x].fa = z, tr[y].fa = x, tr[B].fa = y;
		pushup(y), pushup(x);
	}
	inline void splay(int x, int goal){
		if(x == goal)	return;
		while(tr[x].fa != goal){
			int y = tr[x].fa, z = tr[y].fa;
			int dir1 = !(tr[y].son[1] == x), dir2 = !(tr[z].son[1] == y);
			if(z == goal)	rotate(x, dir1);
			else{
				if(dir1 == dir2)	rotate(y, dir2);
				else	rotate(x, dir1);
				rotate(x, dir2);
			}
		}
		if(goal == 0)	root = x;
	}
	inline int find(int k){
		int now = root;
		while(k){
			if(k <= tr[tr[now].son[0]].size)
				now = tr[now].son[0];
			else if(k == tr[tr[now].son[0]].size + 1)
				return now;
			else{
				k -= tr[tr[now].son[0]].size + 1;
				now = tr[now].son[1];
			}
		}
		return now;
	}
	inline void top(int x){
		x = pos[x];
		splay(x, 0);
		if(!tr[x].son[0])	return;
		if(!tr[x].son[1])	tr[x].son[1] = tr[x].son[0], tr[x].son[0] = 0;
		else{
			int p = find(tr[tr[x].son[0]].size + 2);
			tr[p].son[0] = tr[x].son[0], tr[tr[x].son[0]].fa = p;
			tr[x].son[0] = 0;
			splay(tr[p].son[0], 0);
		}
	}
	inline void bot(int x){
		x = pos[x];
		splay(x, 0);
		if(!tr[x].son[1])	return;
		if(!tr[x].son[0])	tr[x].son[0] = tr[x].son[1], tr[x].son[1] = 0;
		else{
			int p = find(tr[tr[x].son[0]].size);
			tr[p].son[1] = tr[x].son[1], tr[tr[x].son[1]].fa = p;
			tr[x].son[1] = 0;
			splay(tr[p].son[1], 0);
		}
	}
	inline void insert(int x, int t){
		if(!t)	return;
		x = pos[x];
		splay(x, 0);
		int p = find(t == -1 ? tr[tr[root].son[0]].size : tr[tr[root].son[0]].size + 2);
		swap(tr[root].id, tr[p].id);
		swap(pos[tr[root].id], pos[tr[p].id]);
	}
	inline int ask(int x){
		x = pos[x];
		splay(x, 0);
		return tr[tr[x].son[0]].size;
	}
	inline int query(int k){
		return tr[find(k)].id;
	}
	inline void print(int x){
		if(tr[x].son[0])	print(tr[x].son[0]);
		printf("%d ", tr[x].id);
		if(tr[x].son[1])	print(tr[x].son[1]);
	}
}T;

int main(){
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; i++)
		scanf("%d", &a[i]);
	T.root = T.build(1, n, 0);
	while(m--){
		scanf("%s%d", opt, &q);
		switch(opt[0]){
			case 'T': T.top(q); break;
			case 'B': T.bot(q); break;
			case 'I': scanf("%d", &qt); T.insert(q, qt); break;
			case 'A': printf("%d\n", T.ask(q)); break;
			case 'Q': printf("%d\n", T.query(q)); break;
			default: break;
		}
	}
	return 0;
}