题面
题目描述
小 T 有一个很大的书柜。这个书柜的构造有些独特,即书柜里的书是从上至下堆放成一列。她用 到 的正整数给每本书都编了号。
小 T 在看书的时候,每次取出一本书,看完后放回书柜然后再拿下一本。由于这些书太有吸引力了,所以她看完后常常会忘记原来是放在书柜的什么位置。不过小 T 的记忆力是非常好的,所以每次放书的时候至少能够将那本书放在拿出来时的位置附近,比如说她拿的时候这本书上面有 本书,那么放回去时这本书上面就只可能有 、 或 本书。
当然也有特殊情况,比如在看书的时候突然电话响了或者有朋友来访。这时候粗心的小 T 会随手把书放在书柜里所有书的最上面或者最下面,然后转身离开。
久而久之,小 T 的书柜里的书的顺序就会越来越乱,找到特定的编号的书就变得越来越困难。于是她想请你帮她编写一个图书管理程序,处理她看书时的一些操作,以及回答她的两个提问:
- 编号为 的书在书柜的什么位置。
- 从上到下第 本书的编号是多少。
输入格式
第一行有两个整数,分别表示书的个数 以及命令条数 。
第二行有 个整数,第 个整数表示初始时从上向下书第 本书的编号 。
接下来 行,每行表示一个操作。每行初始时有一个字符串 。
- 若 为
Top
,则后有一个整数 ,表示把编号为 的书放在最上面。 - 若 为
Bottom
,则后有一个整数 ,表示把编号为 的书放在最下面。 - 若 为
Insert
,则后有两个整数 ,表示若编号为 的书上面有 本书,则放回这本书时他的上面有 本书。 - 若 为
Ask
,则后面有一个整数 ,表示询问编号为 的书上面有几本书。 - 若 为
Query
,则后面有一个整数 ,询问从上面起第 本书的编号。
输出格式
对于每次查询,输出一行一个整数表示答案。
输入输出样例
样例输入 #1
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
9
9
7
5
3
数据规模与约定
对于 的数据,保证:
- ;
- 是一个 的排列;
- ,, 只可能是输入的五种字符串之一;
- 当编号为 的书上面没有书的时候,不会对它进行
Insert s -1
操作; - 当编号为 的书下面没有书的时候,不会对它进行
Insert s 1
操作。
思路
本题可以使用 FHQ Treap 解决。
设 记录编号为 的书对应的节点,方便后续操作。
执行 Top 操作时将整棵树分裂成三份 —— 之前的书, 本身, 之后的书。然后将其重拍顺序合并。Bottom 操作同理。
对于 Insert 操作,有三种情况:
- 当 时,无需进行任何操作;
- 当 时,将 插入到 前的第 个位置;
- 当 时,将 插入到 后的第 个位置。
对于 Ask 操作直接输出 在树上的排名即可。
对于 Query 操作,在树上执行分裂,将第 本书取出来记录编号再合并即可。
代码
#include <iostream>
#include <cstdlib>
#include <string>
using std::cin;
using std::cout;
const char endl = '\n';
const int N = 8e4 + 5;
struct node {
node *lchild, *rchild, *fa;
std::size_t size;
int value, key;
node()
: lchild(nullptr), rchild(nullptr), fa(nullptr), size(0), value(0), key(rand()) {}
node(int _value)
: lchild(nullptr), rchild(nullptr), fa(nullptr), size(1), value(_value), key(rand()) {}
~node() {
if (lchild != nullptr) delete lchild;
if (rchild != nullptr) delete rchild;
}
inline std::size_t lsize() {
return lchild == nullptr ? 0 : lchild->size;
}
inline std::size_t rsize() {
return rchild == nullptr ? 0 : rchild->size;
}
inline void pushup() {
size = 1;
if (lchild != nullptr) {
size += lchild->size;
lchild->fa = this;
}
if (rchild != nullptr) {
size += rchild->size;
rchild->fa = this;
}
}
inline std::size_t pos() {
std::size_t ret = lsize() + 1;
node *cur = this;
while (cur->fa != nullptr) {
if (cur->fa->rchild == cur) {
ret += cur->fa->lsize() + 1;
}
cur = cur->fa;
}
return ret;
}
};
int n, m;
node *root, *p[N];
std::pair<node *, node *> split(node *u, int k) {
if (u == nullptr) return std::make_pair(nullptr, nullptr);
if (k <= u->lsize()) {
auto o = split(u->lchild, k);
u->lchild = o.second;
u->pushup();
o.second = u;
return o;
}
auto o = split(u->rchild, k - u->lsize() - 1);
u->rchild = o.first;
u->pushup();
o.first = u;
return o;
}
template <typename... Args>
node *merge(node *x, Args... args) {
return merge(x, merge(args...));
}
template <>
node *merge(node *x, node *y) {
if (x == nullptr) return y;
if (y == nullptr) return x;
if (x->key < y->key) {
x->rchild = merge(x->rchild, y);
x->pushup();
return x;
}
y->lchild = merge(x, y->lchild);
y->pushup();
return y;
}
inline void top(const int &x) {
int k = p[x]->pos();
auto p = split(root, k - 1);
auto q = split(p.second, 1);
root = merge(q.first, p.first, q.second);
}
inline void bottom(const int &x) {
int k = p[x]->pos();
auto p = split(root, k - 1);
auto q = split(p.second, 1);
root = merge(p.first, q.second, q.first);
}
inline void insert(const int &x, const int &y) {
if (!y) return;
int k = p[x]->pos();
auto p = split(root, k - 1);
auto q = split(p.second, 1);
if (y > 0) {
auto t = split(q.second, y);
root = merge(p.first, t.first, q.first, t.second);
} else { // y < 0
auto t = split(p.first, k + y - 1);
root = merge(t.first, q.first, t.second, q.second);
}
}
inline int ask(const int &x) {
return p[x]->pos() - 1;
}
inline int query(const int &x) {
auto p = split(root, x - 1);
auto q = split(p.second, 1);
int res = q.first->value;
root = merge(p.first, q.first, q.second);
return res;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m;
for (int i = 1, x; i <= n; i++) {
cin >> x;
root = merge(root, p[x] = new node(x));
}
while (m--) {
std::string op;
int s, t;
cin >> op >> s;
switch (op[0]) {
case 'T': { // op == "Top"
top(s);
break;
}
case 'B': { // op == "Bottom"
bottom(s);
break;
}
case 'I': { // op == "Insert"
cin >> t;
insert(s, t);
break;
}
case 'A': { // op == "Ask"
cout << ask(s) << endl;
break;
}
case 'Q': { // op == "Query"
cout << query(s) << endl;
break;
}
}
}
// Cleanup
delete root;
return 0;
}