102. 【模板】Link-Cut Tree

https://sjzezoj.com/submission/53749

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

Luogu/P3690/P3690.cpp

@@ -1,6 +1,4 @@
 #include <iostream>
-#include <algorithm>
-#include <cstdlib>
 #include <stack>
 
 using std::cin;
@@ -9,171 +7,158 @@ const char endl = '\n';
 
 const int N = 1e5 + 5;
 
-// Link-Cut Tree
 class LinkCutTree {
   private:
-    std::stack<bool> st;
-
     struct node {
-        int p,  // 父亲节点
+        size_t l, r, f;
-            l,  // 左儿子
+        unsigned v, s;
-            r;  // 右儿子
+        bool rev;
-        int pre;
-        int val,   // 节点值
-            sum;   // 异或和
-        int key;   // 权值
-        bool rev;  // 翻转标记
 
         node()
-            : p(0), l(0), r(0), pre(0), val(0), sum(0), key(rand()), rev(false) {}
+            : l(0), r(0), f(0), s(0), v(0), rev(false) {}
+
+        node(unsigned _v, size_t _f)
+            : l(0), r(0), f(_f), s(_v), v(_v), rev(false) {}
+
+        size_t &child(unsigned x) {
+            return !x ? l : r;
+        }
     } tr[N];
 
-    void pushup(int u) {
+    inline void pushup(size_t u) {
-        // 计算异或和
+        tr[u].s = tr[tr[u].l].s ^ tr[u].v ^ tr[tr[u].r].s;
-        tr[u].sum = tr[tr[u].l].sum ^ tr[u].val ^ tr[tr[u].r].sum;
-
-        // 标记父亲节点
-        if (tr[u].l) tr[tr[u].l].p = u;
-        if (tr[u].r) tr[tr[u].r].p = u;
     }
 
-    void pushdown(int u) {
+    inline void pushdown(const size_t &u) {
         if (!tr[u].rev) return;
 
-        tr[u].rev = false;
         std::swap(tr[u].l, tr[u].r);
-        tr[tr[u].l].rev ^= 1;
+        tr[tr[u].l].rev = !tr[tr[u].l].rev;
-        tr[tr[u].r].rev ^= 1;
+        tr[tr[u].r].rev = !tr[tr[u].r].rev;
+        tr[u].rev = false;
     }
 
-    std::pair<int, int> split(int u) {
+    unsigned relation(const size_t &u) {
-        if (st.empty()) {
+        return u == tr[tr[u].f].l ? 0 : 1;
-            pushdown(u);
+    }
-            auto t = std::make_pair(u, tr[u].r);
+
-            tr[u].r = 0;
+    bool isRoot(const size_t &u) {
+        return tr[tr[u].f].l != u && tr[tr[u].f].r != u;
+    }
+
+    void rotate(size_t u) {
+        size_t p = tr[u].f;
+        unsigned x = relation(u);
+
+        if (!isRoot(p)) {
+            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);
-
-            return t;
     }
 
-        bool d = st.top() ^ tr[u].rev;
+    void splay(size_t u) {
+        std::stack<size_t> st;
+
+        size_t cur = u;
+        st.push(cur);
+        while (!isRoot(cur)) {
+            st.push(tr[cur].f);
+            cur = tr[cur].f;
+        }
+
+        while (!st.empty()) {
+            pushdown(st.top());
             st.pop();
-
-        pushdown(u);
-
-        if (d) {
-            auto t = split(tr[u].l);
-            tr[u].l = t.second;
-            pushup(u);
-
-            return std::make_pair(t.first, u);
         }
 
-        auto t = split(tr[u].r);
-        tr[u].r = t.first;
-        pushup(u);
-
-        return std::make_pair(u, t.second);
-    }
-
-    // 合并
-    int merge(int x, int y) {
-        if (!x || !y) return x | y;
-
-        if (tr[x].key < tr[y].key) {
-            pushdown(x);
-            tr[x].r = merge(tr[x].r, y);
-            pushup(x);
-            return x;
-        }
-
-        pushdown(y);
-        tr[y].l = merge(x, tr[y].l);
-        pushup(y);
-        return y;
-    }
-
-    // 是否是根节点
-    bool isRoot(int u) {
-        return !tr[u].p || (tr[tr[u].p].l != u && tr[tr[u].p].r != u);
-    }
-
-    // 查找根节点
-    int findRoot(int u) {
-        while (!st.empty()) st.pop();
         while (!isRoot(u)) {
-            // pushdown(u);
+            if (isRoot(tr[u].f)) {
-            st.push(tr[tr[u].p].l == u);
+                rotate(u);
-            u = tr[u].p;
+            } else if (relation(u) == relation(tr[u].f)) {
+                rotate(tr[u].f);
+                rotate(u);
+            } else {
+                rotate(u);
+                rotate(u);
+            }
         }
-        return u;
     }
 
-    int findLeft(int u) {
+    void access(size_t u) {
-        u = findRoot(u);
+        for (size_t f = 0; u; u = tr[f = u].f) {
-        pushdown(u);
+            splay(u);
+            tr[u].r = f;
+            pushup(u);
+        }
+    }
+
+    void makeRoot(const size_t &u) {
+        access(u);
+        splay(u);
+        tr[u].rev = !tr[u].rev;
+    }
+
+    size_t findRoot(size_t u) {
+        access(u);
+        splay(u);
+
         while (tr[u].l) {
             u = tr[u].l;
-            pushdown(u);
         }
+
         return u;
     }
 
-    int access(int u) {
+    void split(const size_t &x, const size_t &y) {
-        int lst = 0;
+        makeRoot(x);
-
+        access(y);
-        while (u) {
+        splay(y);
-            auto t = split(findRoot(u));
-            tr[findLeft(lst)].pre = 0;
-            lst = merge(t.first, lst);
-            tr[findLeft(t.second)].pre = u;
-            u = tr[findLeft(lst)].pre;
-        }
-
-        return lst;
-    }
-
-    void makeRoot(int u) {
-        tr[access(u)].rev ^= 1;
     }
 
   public:
-    int getRoot(int u) {
+    void set(int p, int v) {
-        return findLeft(access(u));
+        tr[p].s = tr[p].v = v;
     }
 
-    void link(int x, int y) {
+    unsigned query(int x, int y) {
+        split(x, y);
+
+        return tr[y].s;
+    }
+
+    void link(const int &x, const int &y) {
         makeRoot(x);
-        tr[x].pre = y;
+
+        if (findRoot(y) != x) {
+            tr[x].f = y;
+        }
     }
 
     void cut(int x, int y) {
-        makeRoot(x);
+        split(x, y);
-        access(y);
+
-        access(x);
+        if (tr[y].l == x) {
-        tr[y].pre = 0;
+            tr[y].l = 0;
+            tr[x].f = 0;
+        }
     }
 
-    int query(int x, int y) {
+    void change(int p, int v) {
-        makeRoot(x);
+        access(p);
-        access(y);
+        splay(p);
-
+        tr[p].v = v;
-        auto t = split(findRoot(y));
+        pushup(p);
-        int res = tr[t.first].sum;
-        merge(t.first, t.second);
-
-        return res;
-    }
-
-    void change(int u, int val) {
-        makeRoot(u);
-        auto t = split(findRoot(u));
-        tr[u].val = val;
-        merge(t.first, t.second);
-    }
-
-    void set(int u, int val) {
-        tr[u].sum = tr[u].val = val;
     }
 } lct;
 
@@ -203,9 +188,7 @@ int main() {
                 break;
             }
             case 1: {
-                if (lct.getRoot(x) != lct.getRoot(y)) {
                 lct.link(x, y);
-                }
 
                 break;
             }

S2OJ/102/102.cpp

@@ -0,0 +1,209 @@
+#include <iostream>
+#include <stack>
+
+using std::cin;
+using std::cout;
+const char endl = '\n';
+
+const int N = 3e5 + 5;
+
+class LinkCutTree {
+  private:
+    struct node {
+        size_t l, r, f;
+        unsigned v, s;
+        bool rev;
+
+        node()
+            : l(0), r(0), f(0), s(0), v(0), rev(false) {}
+
+        node(unsigned _v, size_t _f)
+            : l(0), r(0), f(_f), s(_v), v(_v), rev(false) {}
+
+        size_t &child(unsigned x) {
+            return !x ? l : r;
+        }
+    } tr[N];
+
+    inline void pushup(size_t u) {
+        tr[u].s = tr[tr[u].l].s ^ tr[u].v ^ tr[tr[u].r].s;
+    }
+
+    inline void pushdown(const size_t &u) {
+        if (!tr[u].rev) return;
+
+        std::swap(tr[u].l, tr[u].r);
+        tr[tr[u].l].rev = !tr[tr[u].l].rev;
+        tr[tr[u].r].rev = !tr[tr[u].r].rev;
+        tr[u].rev = false;
+    }
+
+    unsigned relation(const size_t &u) {
+        return u == tr[tr[u].f].l ? 0 : 1;
+    }
+
+    bool isRoot(const size_t &u) {
+        return tr[tr[u].f].l != u && tr[tr[u].f].r != u;
+    }
+
+    void rotate(size_t u) {
+        size_t p = tr[u].f;
+        unsigned x = relation(u);
+
+        if (!isRoot(p)) {
+            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);
+    }
+
+    void splay(size_t u) {
+        std::stack<size_t> st;
+
+        size_t cur = u;
+        st.push(cur);
+        while (!isRoot(cur)) {
+            st.push(tr[cur].f);
+            cur = tr[cur].f;
+        }
+
+        while (!st.empty()) {
+            pushdown(st.top());
+            st.pop();
+        }
+
+        while (!isRoot(u)) {
+            if (isRoot(tr[u].f)) {
+                rotate(u);
+            } else if (relation(u) == relation(tr[u].f)) {
+                rotate(tr[u].f);
+                rotate(u);
+            } else {
+                rotate(u);
+                rotate(u);
+            }
+        }
+    }
+
+    void access(size_t u) {
+        for (size_t f = 0; u; u = tr[f = u].f) {
+            splay(u);
+            tr[u].r = f;
+            pushup(u);
+        }
+    }
+
+    void makeRoot(const size_t &u) {
+        access(u);
+        splay(u);
+        tr[u].rev = !tr[u].rev;
+    }
+
+    size_t findRoot(size_t u) {
+        access(u);
+        splay(u);
+
+        while (tr[u].l) {
+            u = tr[u].l;
+        }
+
+        return u;
+    }
+
+    void split(const size_t &x, const size_t &y) {
+        makeRoot(x);
+        access(y);
+        splay(y);
+    }
+
+  public:
+    void set(int p, int v) {
+        tr[p].s = tr[p].v = v;
+    }
+
+    unsigned query(int x, int y) {
+        split(x, y);
+
+        return tr[y].s;
+    }
+
+    void link(const int &x, const int &y) {
+        makeRoot(x);
+
+        if (findRoot(y) != x) {
+            tr[x].f = y;
+        }
+    }
+
+    void cut(int x, int y) {
+        split(x, y);
+
+        if (tr[y].l == x) {
+            tr[y].l = 0;
+            tr[x].f = 0;
+        }
+    }
+
+    void change(int p, int v) {
+        access(p);
+        splay(p);
+        tr[p].v = v;
+        pushup(p);
+    }
+} lct;
+
+int n, m;
+
+int main() {
+    std::ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    cin >> n >> m;
+
+    for (int i = 1, x; i <= n; i++) {
+        cin >> x;
+
+        lct.set(i, x);
+    }
+
+    while (m--) {
+        int op, x, y;
+
+        cin >> op >> x >> y;
+
+        switch (op) {
+            case 0: {
+                cout << lct.query(x, y) << endl;
+
+                break;
+            }
+            case 1: {
+                lct.link(x, y);
+
+                break;
+            }
+            case 2: {
+                lct.cut(x, y);
+
+                break;
+            }
+            case 3: {
+                lct.change(x, y);
+
+                break;
+            }
+        }
+    }
+
+    return 0;
+}