「ZJOI2006」书架

题面

题目描述

小 T 有一个很大的书柜。这个书柜的构造有些独特，即书柜里的书是从上至下堆放成一列。她用 $1$ 到 $n$ 的正整数给每本书都编了号。

小 T 在看书的时候，每次取出一本书，看完后放回书柜然后再拿下一本。由于这些书太有吸引力了，所以她看完后常常会忘记原来是放在书柜的什么位置。不过小 T 的记忆力是非常好的，所以每次放书的时候至少能够将那本书放在拿出来时的位置附近，比如说她拿的时候这本书上面有 $x$ 本书，那么放回去时这本书上面就只可能有 $x - 1$、$x$ 或 $x + 1$ 本书。

当然也有特殊情况，比如在看书的时候突然电话响了或者有朋友来访。这时候粗心的小 T 会随手把书放在书柜里所有书的最上面或者最下面，然后转身离开。

久而久之，小 T 的书柜里的书的顺序就会越来越乱，找到特定的编号的书就变得越来越困难。于是她想请你帮她编写一个图书管理程序，处理她看书时的一些操作，以及回答她的两个提问：

• 编号为 $x$ 的书在书柜的什么位置。
• 从上到下第 $i$ 本书的编号是多少。

输入格式

第一行有两个整数，分别表示书的个数 $n$ 以及命令条数 $m$。

第二行有 $n$ 个整数，第 $i$ 个整数表示初始时从上向下书第 $i$ 本书的编号 $p_i$。

接下来 $m$ 行，每行表示一个操作。每行初始时有一个字符串 $op$。

• 若 $op$ 为 Top，则后有一个整数 $s$，表示把编号为 $s$ 的书放在最上面。
• 若 $op$ 为 Bottom，则后有一个整数 $s$，表示把编号为 $s$ 的书放在最下面。
• 若 $op$ 为 Insert，则后有两个整数 $s, t$，表示若编号为 $s$ 的书上面有 $x$ 本书，则放回这本书时他的上面有 $x + t$ 本书。
• 若 $op$ 为 Ask，则后面有一个整数 $s$，表示询问编号为 $s$ 的书上面有几本书。
• 若 $op$ 为 Query，则后面有一个整数 $s$，询问从上面起第 $s$ 本书的编号。

输出格式

对于每次查询，输出一行一个整数表示答案。

输入输出样例

样例输入 #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

数据规模与约定

对于 $100\%$ 的数据，保证：

• $3 \leq n, m \leq 8 \times 10^4$；
• $p_i$ 是一个 $1 \sim n$ 的排列；
• $1 \leq s \leq n$，$-1 \leq t \leq 1$，$op$ 只可能是输入的五种字符串之一；
• 当编号为 $s$ 的书上面没有书的时候，不会对它进行 Insert s -1 操作；
• 当编号为 $s$ 的书下面没有书的时候，不会对它进行 Insert s 1 操作。

思路

本题可以使用 FHQ Treap 解决。

设 $p_x$ 记录编号为 $x$ 的书对应的节点，方便后续操作。

执行 Top 操作时将整棵树分裂成三份 —— $s$ 之前的书，$s$ 本身，$s$ 之后的书。然后将其重拍顺序合并。Bottom 操作同理。

对于 Insert 操作，有三种情况：

1. 当 $t = 0$ 时，无需进行任何操作；
2. 当 $t < 0$ 时，将 $s$ 插入到 $s$ 前的第 $-t$ 个位置；
3. 当 $t > 0$ 时，将 $s$ 插入到 $s$ 后的第 $t$ 个位置。

对于 Ask 操作直接输出 $s$ 在树上的排名即可。

对于 Query 操作，在树上执行分裂，将第 $s$ 本书取出来记录编号再合并即可。

代码

#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;
}