#104. 普通平衡树

https://loj.ac/s/1515123

LibreOJ/104/104.cpp

@@ -5,274 +5,261 @@ using std::cin;
 using std::cout;
 const char endl = '\n';
 
-template <typename T>
+const int N = 1e5 + 5;
+
 class Splay {
   private:
+    size_t root, cnt;
+
     struct node {
-        T value;
+        size_t l, r, f, c, s;
-        node *lchild, *rchild, *parent, **root;
+        int v;
-        std::size_t size, count;
 
         node()
-            : value(0), lchild(nullptr), rchild(nullptr), parent(nullptr), root(nullptr), size(0), count(0) {}
+            : l(0), r(0), f(0), c(0), s(0), v(0) {}
 
-        node(const T &_value, node *_parent, node **_root)
+        node(int _v, int _f)
-            : value(_value), lchild(nullptr), rchild(nullptr), parent(_parent), root(_root), size(1), count(1) {}
+            : l(0), r(0), f(_f), c(1), s(1), v(_v) {}
 
-        ~node() {
+        size_t &child(unsigned x) {
-            if (lchild != nullptr) delete lchild;
+            return !x ? l : r;
-            if (rchild != nullptr) delete rchild;
-        }
-
-        node *&child(unsigned int x) {
-            return !x ? lchild : rchild;
-        }
-
-        unsigned int relation() const {
-            // 如果当前节点是其父亲节点的左儿子则返回 0，否则返回 1
-            return this == parent->lchild ? 0 : 1;
-        }
-
-        // 左儿子大小
-        std::size_t lsize() const {
-            return lchild == nullptr ? 0 : lchild->size;
-        }
-
-        // 右儿子大小
-        std::size_t rsize() const {
-            return rchild == nullptr ? 0 : rchild->size;
         }
+    } tr[N];
 
     // 上传信息
-        void pushup() {
+    void pushup(size_t u) {
-            size = lsize() + count + rsize();
+        tr[u].s = tr[tr[u].l].s + tr[tr[u].r].s + tr[u].c;
     }
 
-        // 旋转
+    unsigned relation(size_t u) {
-        void rotate() {
+        // 如果当前节点是其父亲节点的左儿子则返回 0，否则返回 1
-            node *old = parent;
+        return u == tr[tr[u].f].l ? 0 : 1;
-            unsigned int x = relation();
-
-            if (old->parent != nullptr) {
-                old->parent->child(old->relation()) = this;
-            }
-            parent = old->parent;
-
-            old->child(x) = child(x ^ 1);
-            if (child(x ^ 1) != nullptr) {
-                child(x ^ 1)->parent = old;
     }
 
-            child(x ^ 1) = old;
+    void rotate(size_t u) {
-            old->parent = this;
+        // 旧的父节点
+        size_t p = tr[u].f;
 
-            old->pushup();
+        // 当前节点与父节点之间的关系
-            pushup();
+        unsigned x = relation(u);
 
-            if (parent == nullptr) *root = this;
+        // 当前节点 <-> 父节点的父节点
+        if (tr[p].f) {
+            tr[tr[p].f].child(relation(p)) = u;
+        }
+        tr[u].f = tr[p].f;
+
+        // 原先的另一个子节点 <-> 父节点
+        if (tr[u].child(x ^ 1)) {
+            tr[tr[u].child(x ^ 1)].f = p;
+        }
+        tr[p].child(x) = tr[u].child(x ^ 1);
+
+        // 原先的父节点 -> 子节点
+        tr[u].child(x ^ 1) = p;
+        tr[p].f = u;
+
+        // 更新节点信息
+        pushup(p);
+        pushup(u);
     }
 
     // Splay
-        void splay(node *target = nullptr) {
+    //
-            while (parent != target) {
+    // 旋转到给定的位置（target），默认行为为旋转为根节点
-                if (parent->parent == target) {  // 父节点是目标节点
+    void splay(size_t u, size_t t = 0) {
-                    rotate();
+        while (tr[u].f != t) {
-                } else if (relation() == parent->relation()) {  // 关系相同
+            if (tr[tr[u].f].f == t) {
-                    parent->rotate();
+                rotate(u);
-                    rotate();
+            } else if (relation(u) == relation(tr[u].f)) {
+                rotate(tr[u].f);
+                rotate(u);
             } else {
-                    rotate();
+                rotate(u);
-                    rotate();
+                rotate(u);
             }
         }
+
+        // 更新根节点
+        if (!t) root = u;
     }
 
-        // 前驱：左子树的最右点
+    // 前驱
-        node *predecessor() {
+    //
-            node *pred = lchild;
+    // 左子树的最右点
+    size_t _predecessor(size_t u) {
+        size_t cur = tr[u].l;
 
-            while (pred->rchild != nullptr) {
+        while (tr[cur].r) {
-                pred = pred->rchild;
+            cur = tr[cur].r;
         }
 
-            return pred;
+        return cur;
     }
 
-        // 后继：右子树的最左点
+    // 后继
-        node *successor() {
+    //
-            node *succ = rchild;
+    // 右子树的最左点
+    size_t _successor(size_t u) {
+        size_t cur = tr[u].r;
 
-            while (succ->lchild != nullptr) {
+        while (tr[cur].l) {
-                succ = succ->lchild;
+            cur = tr[cur].l;
         }
 
-            return succ;
+        return cur;
     }
-    } * root;
 
-    // 插入（内部函数）
+    size_t _find(const int &v) {
-    node *_insert(const T &value) {
+        size_t u = root;
-        node **target = &root, *parent = nullptr;
 
-        while (*target != nullptr && (*target)->value != value) {
+        while (u && tr[u].v != v) {
-            parent = *target;
+            // 根据数值大小向左右子树迭代
-            parent->size++;
+            u = v < tr[u].v ? tr[u].l : tr[u].r;
+        }
 
-            // 根据大小向左右子树迭代
+        if (u) splay(u);
-            if (value < parent->value) {
+
-                target = &parent->lchild;
+        return u;
+    }
+
+    size_t _insert(const int &v) {
+        size_t u = root, f = 0;
+
+        while (u && tr[u].v != v) {
+            f = u;
+            // 根据数值大小向左右子树迭代
+            u = v < tr[u].v ? tr[u].l : tr[u].r;
+        }
+
+        if (u) {
+            tr[u].c++;
+            tr[u].s++;
         } else {
-                target = &parent->rchild;
+            tr[u = ++cnt] = node(v, f);
-            }
+            if (f) tr[f].child(v > tr[f].v) = u;
         }
 
-        if (*target == nullptr) {
+        splay(u);
-            *target = new node(value, parent, &root);
-        } else {
-            (*target)->count++;
-            (*target)->size++;
-        }
-
-        (*target)->splay();
 
         return root;
     }
 
-    // 查找指定的值对应的节点
+    void _erase(size_t u) {
-    node *find(const T &value) {
+        if (!u) return;
-        node *node = root;  // 从根节点开始查找
 
-        while (node != nullptr && value != node->value) {
+        if (tr[u].c > 1) {  // 存在重复的数
-            if (value < node->value) {
+            splay(u);
-                node = node->lchild;
+            tr[u].c--;
-            } else {
+            tr[u].s--;
-                node = node->rchild;
-            }
-        }
-
-        if (node != nullptr) {
-            node->splay();
-        }
-
-        return node;
-    }
-
-    // 删除
-    void erase(node *u) {
-        if (u == nullptr) return;
-
-        if (u->count > 1) {  // 存在重复的数
-            u->splay();
-            u->count--;
-            u->size--;
 
             return;
         }
 
-        node *pred = u->predecessor(),
+        size_t pred = _predecessor(u),
-             *succ = u->successor();
+               succ = _successor(u);
 
-        pred->splay();
+        splay(pred);        // 将前驱旋转到根节点
-        succ->splay(pred);
+        splay(succ, pred);  // 将后继旋转到根节点的右儿子
 
-        delete succ->lchild;
+        tr[succ].l = 0;  // 此时要删的节点为根节点的左儿子且为叶子节点
-        succ->lchild = nullptr;
 
-        succ->pushup();
+        // 更新节点信息
-        pred->pushup();
+        pushup(succ);
+        pushup(pred);
     }
 
   public:
     Splay()
-        : root(nullptr) {
+        : root(0), cnt(0) {
-        insert(std::numeric_limits<T>::min());
+        // 插入哨兵节点
-        insert(std::numeric_limits<T>::max());
+        insert(std::numeric_limits<int>::min());
-    }
+        insert(std::numeric_limits<int>::max());
-
-    ~Splay() {
-        delete root;
     }
 
     // 插入
-    void insert(const T &value) {
+    void insert(const int &v) {
-        _insert(value);
+        _insert(v);
     }
 
     // 删除
-    void erase(const T &value) {
+    void erase(const int &v) {
-        node *node = find(value);
+        _erase(_find(v));
-
-        if (node == nullptr) return;
-
-        erase(node);
     }
 
     // 排名
-    unsigned int rank(const T &value) {
+    unsigned rank(const int &v) {
-        node *node = find(value);
+        size_t u = _find(v);
 
-        if (node == nullptr) {
+        if (!u) {  // 不存在则插入一个方便查找
-            node = _insert(value);
+            u = _insert(v);
-            // 此时 node 已经成为根节点，直接计算即可
-            int res = node->lsize();  // 由于「哨兵」的存在，此处无需 -1
-            erase(node);
 
-            return res;
+            // 此时 u 已经成为根节点，直接取左子树大小即可
+            unsigned r = tr[tr[u].l].s;
+
+            _erase(u);
+
+            return r;
         }
 
-        // 此时 node 已经成为根节点，直接计算即可
+        return tr[tr[u].l].s;
-        return node->lsize();
     }
 
     // 选择
-    const T &select(int k) {
+    const int &select(unsigned k) {
-        node *node = root;
+        size_t u = root;
 
-        while (k < node->lsize() || k >= node->lsize() + node->count) {
+        while (k < tr[tr[u].l].s || k >= tr[tr[u].l].s + tr[u].c) {
-            if (k < node->lsize()) {  // 所需的节点在左子树中
+            if (k < tr[tr[u].l].s) {
-                node = node->lchild;
+                u = tr[u].l;
             } else {
-                k -= node->lsize() + node->count;
+                k -= tr[tr[u].l].s + tr[u].c;
-                node = node->rchild;
+                u = tr[u].r;
             }
         }
 
-        node->splay();
+        splay(u);
 
-        return node->value;
+        return tr[u].v;
     }
 
     // 前驱
-    const T &predecessor(const T &value) {
+    const int &predecessor(const int &v) {
-        node *node = find(value);
+        size_t u = _find(v);
 
-        if (node == nullptr) {
+        if (!u) {  // 不存在则插入一个方便查找
-            node = _insert(value);
+            u = _insert(v);
-            const T &result = node->predecessor()->value;
+
-            erase(node);
+            const int &r = tr[_predecessor(u)].v;
-            return result;
+
+            _erase(u);  // 删除
+
+            return r;
         }
 
-        return node->predecessor()->value;
+        return tr[_predecessor(u)].v;
     }
 
     // 后继
-    const T &successor(const T &value) {
+    const int &successor(const int &v) {
-        node *node = find(value);
+        size_t u = _find(v);
 
-        if (node == nullptr) {
+        if (!u) {  // 不存在则插入一个方便查找
-            node = _insert(value);
+            u = _insert(v);
-            const T &result = node->successor()->value;
+
-            erase(node);
+            const int &r = tr[_successor(u)].v;
-            return result;
+
+            _erase(u);  // 删除
+
+            return r;
         }
 
-        return node->successor()->value;
+        return tr[_successor(u)].v;
     }
 };
 
 int n;
-Splay<int> tree;
+Splay tree;
 
 int main() {
     std::ios::sync_with_stdio(false);
@@ -280,42 +267,23 @@ int main() {
 
     cin >> n;
 
-    for (int i = 1; i <= n; i++) {
+    while (n--) {
         int op, x;
 
         cin >> op >> x;
 
-        switch (op) {
+        if (op == 1) {
-            case 1: {
             tree.insert(x);
-
+        } else if (op == 2) {
-                break;
-            }
-            case 2: {
             tree.erase(x);
-
+        } else if (op == 3) {
-                break;
-            }
-            case 3: {
             cout << tree.rank(x) << endl;
-
+        } else if (op == 4) {
-                break;
-            }
-            case 4: {
             cout << tree.select(x) << endl;
-
+        } else if (op == 5) {
-                break;
-            }
-            case 5: {
             cout << tree.predecessor(x) << endl;
-
+        } else {  // op == 6
-                break;
-            }
-            case 6: {
             cout << tree.successor(x) << endl;
-
-                break;
-            }
         }
     }