Splay树简单操作

最新推荐文章于 2019-08-05 11:16:00 发布
最新推荐文章于 2019-08-05 11:16:00 发布
阅读量315 收藏
点赞数
分类专栏： 模板\算法\知识点总结 splay 文章标签： splay 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oi_Konnyaku/article/details/74942172
版权

前几天刚刚自学了一下splay，发现思路真简单实现起来好麻烦

先贴一下头文件

# include <stdio.h>
# include <stdlib.h>
# include <iostream>
# include <string.h>
# define ll long long
# define RG register//卡常
# define IL inline//再卡常
# define UN unsigned
# define mem(a, b) memset(a, b, sizeof(a))
# define min(a, b) ((a) < (b)) ? (a) : (b)
# define max(a, b) ((a) > (b)) ? (a) : (b)
using namespace std;
  • 核心旋转操作 Splay操作（之后的操作基本上都要用到）
    1.当旋转的节点为爷爷节点的左儿子的左儿子时
    进行两次右旋操作，先转父亲，再转自己
    2.当旋转的节点为爷爷节点的左儿子的右儿子时
    进行一次左旋操作，一次右旋操作，都转自己
    3.如果要转到的点的为爷爷节点的右儿子，直接左旋
    4.剩下两种情况把以上两种情况左右互换即可
    贴一段代码
IL void Rot(RG tree *x, RG int i){ //0为左旋，1为右旋，0为左儿子，1为右儿子
    RG tree *y = x -> fa;
    y -> ch[!i] = x -> ch[i];
    if(x -> ch[i] != NULL) x -> ch[i] -> fa = y;
    x -> fa = y -> fa;
    if(y -> fa != NULL)
        if(y -> fa -> ch[0] == y) y -> fa -> ch[0] = x;
        else y -> fa -> ch[1] = x;
    x -> ch[i] = y; y -> fa = x;
    if(y == root) root = x;
}

IL void Splay(RG tree *x, RG tree *f){
    while(x -> fa != f)
        if(x -> fa -> fa == f)
            if(x == x -> fa -> ch[0]) Rot(x, 1);
            else Rot(x, 0);
        else{
            RG tree *y = x -> fa, *z = y -> fa;
            if(z -> ch[0] == y)
                if(y -> ch[0] == x) Rot(y, 1), Rot(x, 1);
                else Rot(x, 0), Rot(x, 1);
            else
                if(y -> ch[1] == x) Rot(y, 0), Rot(x, 0);
                else Rot(x, 1), Rot(x, 0);
        }
}
  • 插入操作
    和二叉排序树一样，只不过弄完后把它Splay到根（不要问为什么）
    丑陋的代码
IL void Insert(RG int num){
    RG tree *x = root;
    if(x == NULL){
        x = new tree;
        x -> val = num;
        root = x;
    }
    else while(2333)
        if(num < x -> val){
            if(x -> ch[0] == NULL){
                x -> ch[0] = new tree;
                x -> ch[0] -> fa = x;
                x = x -> ch[0];
                x -> val = num;
                break;
            }
            x = x -> ch[0];
        }
        else if(num > x -> val){
            if(x -> ch[1] == NULL){
                x -> ch[1] = new tree;
                x -> ch[1] -> fa = x;
                x = x -> ch[1];
                x -> val = num;
                break;
            }
            x = x -> ch[1];
        }
    Splay(x, NULL);
}
  • 查找
    与二叉排序树一样
IL void Find(RG int num){
    RG tree *x = root; 
    while(x -> val != num)
        if(num < x -> val) x = x -> ch[0];
        else x = x -> ch[1];
    Splay(x, NULL);
}
  • 查找前驱和后缀
    前驱，跳到它的左儿子再不停地跳右儿子
    后继，跳到它的右儿子再不停地跳左儿子
IL void Findmx(RG tree *x, RG tree *f, RG int i){ //0表示后继，1表示前驱，f为该节点，x为它的左或右儿子1
    while(x -> ch[i] != NULL) x = x -> ch[i];
    Splay(x, f);
}
  • 删除操作
    先找到数字的位置，Splay到根，删掉它，找它左子树中的最大数（前驱）Splay到它下面作为新的根，连接右子树即可
    代码
IL void Delete(RG int num){
    Find(num);
    RG tree *x = root;
    else if(x -> ch[0] == NULL || x -> ch[1] == NULL)
        if(x -> ch[0] != NULL) root = x -> ch[0], root -> fa = NULL;
        else if(x -> ch[1] != NULL) root = x -> ch[1], root -> fa = NULL;
        else root = NULL;
    else{
        Findmx(x -> ch[0], x, 1);
        root = x -> ch[0];
        root -> fa = NULL;
        root -> ch[1] = x -> ch[1];
        if(root -> ch[1] != NULL) root -> ch[1] -> fa = root;
    }
}
  • 查找某数的排名
    实行查找操作，排名就是他左子树大小加一
IL int Size(RG tree *x){
    return (x == NULL) ? 0 : x -> size + 1;
}

IL int Rank(RG int num){
    Find(num);
    return Size(root -> ch[0]) + 1;
}
  • 查找排名为k的数
    若大于当前的左子树大小加一，跳右儿子，k -= 左子树大小加一；
    否则跳右节点
IL int Pos(RG int num){
    RG tree *x = root;
    while(2333){
        RG int l = Size(x -> ch[0]);
        if(num == l + 1) break;
        if(num <= l) x = x -> ch[0];
        else{
            num -= (l + 1);
            x = x -> ch[1];
        }
    }
    return x -> val;
}

以上就是基本操作

  • 关于更新
    如子树大小
IL int Size(RG tree *x){
    return (x == NULL) ? 0 : x -> size + 1;
}

IL void Updata(RG tree *x){
    if(x == NULL) return;
    x -> size = Size(x -> ch[0]) + Size(x -> ch[1]);
}

IL void Rot(RG tree *x, RG int i){ //0为左旋，1为右旋 
    RG tree *y = x -> fa;
    y -> ch[!i] = x -> ch[i];
    if(x -> ch[i] != NULL) x -> ch[i] -> fa = y;
    x -> fa = y -> fa;
    if(y -> fa != NULL)
        if(y -> fa -> ch[0] == y) y -> fa -> ch[0] = x;
        else y -> fa -> ch[1] = x;
    x -> ch[i] = y; y -> fa = x;
    Updata(y); //大佬说写在这里
    if(y == root) root = x;
}

IL void Splay(RG tree *x, RG tree *f){
    while(x -> fa != f)
        if(x -> fa -> fa == f)
            if(x == x -> fa -> ch[0]) Rot(x, 1);
            else Rot(x, 0);
        else{
            RG tree *y = x -> fa, *z = y -> fa;
            if(z -> ch[0] == y)
                if(y -> ch[0] == x) Rot(y, 1), Rot(x, 1);
                else Rot(x, 0), Rot(x, 1);
            else
                if(y -> ch[1] == x) Rot(y, 0), Rot(x, 0);
                else Rot(x, 1), Rot(x, 0);
        }
    Updata(x); //大佬说要写在这里
}

简单的栗子：
链接bzoj3224
请读者思考2分钟
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
好了直接看代码
代码调了好久QAQ

# include <stdio.h>
# include <stdlib.h>
# include <iostream>
# include <string.h>
# define ll long long
# define RG register
# define IL inline
# define UN unsigned
# define mem(a, b) memset(a, b, sizeof(a))
# define min(a, b) ((a) < (b)) ? (a) : (b)
# define max(a, b) ((a) > (b)) ? (a) : (b)
using namespace std;

IL int Get(){
    char c = '!'; int z = 1, num = 0;
    while(c != '-' && (c < '0' || c > '9'))
        c = getchar();
    if(c == '-')
        z = -1, c = getchar();
    while(c >= '0' && c <= '9')
        num = num * 10 + c - '0', c = getchar();
    return num * z;
}

struct tree{
    tree *fa, *ch[2];
    int val, tot, size;//tot用来判断重复的数
    IL tree(){
        fa = ch[0] = ch[1] = NULL;
        size = val = tot = 0;
    }
} *root;

IL int Size(RG tree *x){
    return (x == NULL) ? 0 : x -> size + x -> tot + 1;
}

IL void Updata(RG tree *x){
    if(x == NULL) return;
    x -> size = Size(x -> ch[0]) + Size(x -> ch[1]);
}

IL void Rot(RG tree *x, RG int i){ //0为左旋，1为右旋 
    RG tree *y = x -> fa;
    y -> ch[!i] = x -> ch[i];
    if(x -> ch[i] != NULL) x -> ch[i] -> fa = y;
    x -> fa = y -> fa;
    if(y -> fa != NULL)
        if(y -> fa -> ch[0] == y) y -> fa -> ch[0] = x;
        else y -> fa -> ch[1] = x;
    x -> ch[i] = y; y -> fa = x; Updata(y);
    if(y == root) root = x;
}

IL void Splay(RG tree *x, RG tree *f){
    while(x -> fa != f)
        if(x -> fa -> fa == f)
            if(x == x -> fa -> ch[0]) Rot(x, 1);
            else Rot(x, 0);
        else{
            RG tree *y = x -> fa, *z = y -> fa;
            if(z -> ch[0] == y)
                if(y -> ch[0] == x) Rot(y, 1), Rot(x, 1);
                else Rot(x, 0), Rot(x, 1);
            else
                if(y -> ch[1] == x) Rot(y, 0), Rot(x, 0);
                else Rot(x, 1), Rot(x, 0);
        }
    Updata(x);
}

IL void Insert(RG int num){
    RG tree *x = root;
    if(x == NULL){
        x = new tree;
        x -> val = num;
        root = x;
    }
    else if(num == x -> val) x -> tot++, root = x;
    else while(2333)
        if(num < x -> val){
            if(x -> ch[0] == NULL){
                x -> ch[0] = new tree;
                x -> ch[0] -> fa = x;
                x = x -> ch[0];
                x -> val = num;
                break;
            }
            x = x -> ch[0];
        }
        else if(num > x -> val){
            if(x -> ch[1] == NULL){
                x -> ch[1] = new tree;
                x -> ch[1] -> fa = x;
                x = x -> ch[1];
                x -> val = num;
                break;
            }
            x = x -> ch[1];
        }
        else{
            x -> tot++;
            break;
        }
    Splay(x, NULL);
}

IL void Find(RG int num){
    RG tree *x = root; 
    while(x -> val != num)
        if(num < x -> val) x = x -> ch[0];
        else x = x -> ch[1];
    Splay(x, NULL);
}

IL void Findmx(RG tree *x, RG tree *f, RG int i){
    while(x -> ch[i] != NULL) x = x -> ch[i];
    Splay(x, f);
}

IL void Delete(RG int num){
    Find(num);
    RG tree *x = root;
    if(root -> tot) root -> tot--;
    else if(x -> ch[0] == NULL || x -> ch[1] == NULL)
        if(x -> ch[0] != NULL) root = x -> ch[0], root -> fa = NULL;
        else if(x -> ch[1] != NULL) root = x -> ch[1], root -> fa = NULL;
        else root = NULL;
    else{
        Findmx(x -> ch[0], x, 1);
        root = x -> ch[0];
        root -> fa = NULL;
        root -> ch[1] = x -> ch[1];
        if(root -> ch[1] != NULL) root -> ch[1] -> fa = root;
    }
}

IL int Rank(RG int num){
    Find(num);
    return Size(root -> ch[0]) + 1;
}

IL int Pos(RG int num){
    RG tree *x = root;
    while(2333){
        RG int l = Size(x -> ch[0]);
        if(num > l && num <= l + x -> tot + 1) break;
        if(num <= l) x = x -> ch[0];
        else{
            num -= (l + x -> tot + 1);
            x = x -> ch[1];
        }
    }
    return x -> val;
}

int main(){
    RG int n = Get(), opt, x;
    while(n--){
        opt = Get(); x = Get();
        if(opt == 1) Insert(x);
        if(opt == 2) Delete(x);
        if(opt == 3) printf("%d\n", Rank(x));
        if(opt == 4) printf("%d\n", Pos(x));
        //找前驱后缀：插入数后再删除，显然有更快的（不想打其他方法了，反正能过）
        if(opt == 5){
            Insert(x);
            Findmx(root -> ch[0], NULL, 1);
            printf("%d\n", root -> val);
            Delete(x);
        }
        if(opt == 6){
            Insert(x);
            Findmx(root -> ch[1], NULL, 0);
            printf("%d\n", root -> val);
            Delete(x);
        }
    }
    return 0;
}

  • 关于区间操作
    一张丑陋的图

    把l-1splay到根，r+1splay到根的右儿子，则图中那个丑陋的子树就是要求的[l，r]了。

  • 删除区间
    直接断开边（显然浪费空间，自己想办法目前没遇到MLE的情况）

  • 翻转区间
    用类似于线段树的懒懒的lazy标记，每次Find，splay等操作时把标记下放，更换两个子树

又一个栗子
链接bzoj3223
再思考两分钟
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
，
看代码

# include <stdio.h>
# include <stdlib.h>
# include <iostream>
# include <string.h>
# define ll long long
# define RG register
# define IL inline
# define UN unsigned
# define mem(a, b) memset(a, b, sizeof(a))
# define min(a, b) ((a) < (b)) ? (a) : (b)
# define max(a, b) ((a) > (b)) ? (a) : (b)
using namespace std;

IL int Get(){
    char c = '!'; int z = 1, num = 0;
    while(c != '-' && (c < '0' || c > '9'))
        c = getchar();
    if(c == '-')
        z = -1, c = getchar();
    while(c >= '0' && c <= '9')
        num = num * 10 + c - '0', c = getchar();
    return num * z;
}

struct tree{
    tree *fa, *ch[2];
    int size, lazy, pos;
    IL tree(){
        fa = ch[0] = ch[1] = NULL;
        pos = lazy = size = 0;
    }
    IL void Pushdown(){//下放
        if(!lazy) return;
        lazy = 0;
        if(ch[1] == NULL && ch[0] == NULL) return;
        if(ch[0] != NULL) ch[0] -> lazy ^= 1;
        if(ch[1] != NULL) ch[1] -> lazy ^= 1;
        swap(ch[0], ch[1]);
    }
} *root;
int n;

IL int Size(RG tree *x){
    return (x == NULL) ? 0 : x -> size + 1;
}

IL void Updata(RG tree *x){
    if(x == NULL) return;
    x -> size = Size(x -> ch[0]) + Size(x -> ch[1]);
}

IL void Dfs(RG tree *x){
    if(x == NULL) return;
    x -> Pushdown();
    Dfs(x -> ch[0]);
    if(x -> pos && x -> pos <= n)
        printf("%d ", x -> pos);
    Dfs(x -> ch[1]);
}

IL void Rot(RG tree *x, RG int i){ //0为左旋，1为右旋
    RG tree *y = x -> fa;
    x -> Pushdown(); y -> Pushdown();
    y -> ch[!i] = x -> ch[i];
    if(x -> ch[i] != NULL) x -> ch[i] -> fa = y;
    x -> fa = y -> fa;
    if(y -> fa != NULL)
        if(y -> fa -> ch[0] == y) y -> fa -> ch[0] = x;
        else y -> fa -> ch[1] = x;
    x -> ch[i] = y; y -> fa = x; Updata(y);
    if(y == root) root = x;
}

IL void Splay(RG tree *x, RG tree *f){
    while(x -> fa != f){
        x -> Pushdown();
        if(x -> fa -> fa == f)
            if(x == x -> fa -> ch[0]) Rot(x, 1);
            else Rot(x, 0);
        else{
            RG tree *y = x -> fa, *z = y -> fa;
            if(z -> ch[0] == y)
                if(y -> ch[0] == x) Rot(y, 1), Rot(x, 1);
                else Rot(x, 0), Rot(x, 1);
            else
                if(y -> ch[1] == x) Rot(y, 0), Rot(x, 0);
                else Rot(x, 1), Rot(x, 0);
        }
    }
     Updata(x);
}

IL tree *Build(RG int l, RG int r, RG tree *f){
    RG int mid = (l + r) >> 1;
    tree *x = new tree;
    x -> pos = mid;
    x -> fa = f;
    if(mid > l) x -> ch[0] = Build(l, mid - 1, x);
    if(mid < r) x -> ch[1] = Build(mid + 1, r, x);
    Updata(x);
    return x;
}

IL void Find(RG int num, RG tree *f){
    RG tree *x = root;
    while(2333){
        x -> Pushdown();
        RG int l = Size(x -> ch[0]);
        if(num < l) x = x -> ch[0];
        else if(num == l) break;
        else{
            num -= (l + 1);
            x = x -> ch[1];
        }
    }
    Splay(x, f);
}

IL void Turn(){
    RG int l = Get(), r = Get();
    Find(l - 1, NULL); Find(r + 1, root);
    root -> ch[1] -> ch[0] -> lazy ^= 1;
}

int main(){
    n = Get();
    RG int m = Get();
    root = Build(0, n + 1, NULL);
    while(m--) Turn();
    Dfs(root);
    printf("\n");
    return 0;
}

解释或代码错误还请大佬指出，本蒟蒻一定会改

Cyhlnj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[Splay伸展树]splay树入门级教程
SKY的C
02-28 1万+
本弱鸟对于SPLAY树的一些理解。。。
无旋Treap——从入门到放弃
Friedrich_Taylor的博客
09-22 5098
前言已经是从入门到放弃的第四篇了。 但是本文并不打算给大家讲无旋Treap复杂度证明一类的。 很显然每次操作都是期望Olog(n)的{\bf O}\log(n)的什么是Treap？Treap=Tree+heap 其核心思想在于在权值上维护一棵二叉查找树，在优先级上维护一个堆 有旋treap利用旋转操作来维护堆的性质， 而无旋treap利用有序构树维护堆的性质。无旋Treap的两大构树顺序：
Splay Tree的删除操作
靖空间
05-31 3429
Splay Tree的插入操作，搜索操作，和删除操作都实现了，那么就可以使用来解题了。 指针的删除操作的处理还是那么难的，很多坎需要避开. 同一个坎还是坑了我好多次，就是指针传递的问题，什么时候需要修改指针本身的值，就必须返回指针或者传递指针的指针，或者传递指针的的实参。 这里的删除操作就是需要改变传递到函数的指针本身的，所以我这里使用了返回指针操作。 还有删除树的问题，之前的代码没做删除
splay区间操作
执米之手，与米偕老
11-18 2577
SplayTree区间操作              -----------区间修改 题目：http://poj.org/problem?id=3468 题目大意：给出一组数字，区间整体增加一个值，区间查询和 思路：很经典的区间操作的题目，因此思路也不用自己想， 都是各路以例题的形式给出 之前用线段数写的，用了1938MS，今天用splay写，耗时2875. 说一下splay操作的几个
Splay树题解1
最新发布
08-03
Splay树是一种自调整的二叉查找树，它通过“旋转”操作使得频繁访问的节点更容易接近根节点，从而提高查找效率。这种数据结构能够高效地处理各种操作，包括查找、插入、删除以及一些特定的区间操作。Splay树的特性...
数据结构伸展树splay.rar
07-16
伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由丹尼尔·斯立特Daniel Sleator 和 罗伯特·恩卓·塔扬Robert Endre Tarjan 在1985年发明的。 [1] 在伸展树上...
Splay树及其应用_朱全民.ppt
09-14
对比AVL树，Splay树的编程实现更简单，虽然常数因子较大，但因为自调整特性，它更适合于访问模式不确定或不均匀的情况。 另一个例子，“郁闷的出纳员”，需要处理四种类型的命令，涉及集合的插入、批量修改和查询。...
splay和动态树入门必看
10-05
3. **简单实现**：Splay树的旋转操作相对简单，包括左右旋、右左旋和左右右旋等，便于理解和实现。 4. **自适应性**：Splay树可以根据操作序列自动优化结构，无需预先知道操作模式。 在ACM/ICPC和IOI等竞赛中，...
node-splay-tree:展开树实现
07-03
**展开树（Splay Tree）**是一种自调整的二叉搜索树数据结构，它通过特定的树操作使得最近访问的节点被移动到树的根部，从而提高查询效率。在JavaScript编程环境中，`node-splay-tree`库提供了一个用于创建和操作...
【平衡二叉树】宠物收养所
void* ptr = &OI;
04-19 847
Description 最近，阿Q开了一间宠物收养所。收养所提供两种服务：收养被主人遗弃的宠物和让新的主人领养这些宠物。每个领养者都希望领养到自己满意的宠物，阿Q根据领养者的要求通过他自己发明的一个特殊的公式，得出该领养者希望领养的宠物的特点值a（a是一个正整数，a<2^31），而他也给每个处在收养所的宠物一个特点值。这样他就能够很方便的处理整个领养宠物的过程了，宠物收养所总是会有两种情况发生：被
洛谷P3919 【模板】可持久化数组（可持久化线段树/平衡树）
wzw
05-14 206
题目链接：https://www.luogu.org/problemnew/show/P3919 题解：可持久化数组模板题 可持久化数组就是主席树！ 直接附上代码： #include<bits/stdc++.h> using namespace std; const int maxn = 1e6 + 10; int n, q; int old, type, loc, val; te...
splay伸展树 指针型 平衡树基本操作 序列维护 详细讲解+总结
anantheparty的博客
12-21 3435
转载请保留本博客源地址：http://blog.csdn.net/u011327397/article/details/53783700 本来是要去学lct，然后看到要用splay我又不会，就开始看splay了，然后发现splay艹起来特别爽，但是序列操作网上没看到有详讲的，理解的时候很多奇怪的问题（无限RE）再加上指针调试复杂度高，花了很多时间，就觉得来写一个讲解吧。
Splay Tree（伸展树总结）
weixin_34301132的博客
04-21 243
伸展树是比较神奇的，它可以做很多线段树不能实现的事情。 最近做伸展树做了好长时间了，现在重新把题目整理下，代码统一些一下呢。说明多是含在代码的注释中。 刚开始学，可以看论文，然后按照别人的代码去写。 我是参照cxlove大神学习的：http://blog.csdn.net/acm_cxlove/article/details/7815019 还有HH的：http://www.notonly...
[ 模板 ] Treap指针版
小鬼66
11-25 584
#include <stdio.h> #include <stdlib.h>struct Treap { Treap *Lson,*Rson; int val,key,cnt,size; Treap(int num) { Lson = Rson = NULL; val = num; key = rand();
伸展树（Splay树）的简要操作
dbsaf26628的专栏
04-08 143
　　伸展树（splay树），是二叉排序树的一种。【两个月之前写过，今天突然想写个博客。。。】 　　伸展树和一般的二叉排序树不同的是，在每次执行完插入、查询、删除等操作后，都会自动平衡这棵树。（说是自动，也就是多了一段代码，把这个节点提到根节点的位置上罢了） 　　伸展树的调整是基于两种旋转操作的【左旋右旋嘛】。 　　分别是这样的（对2号节点操作）： 　　 　　 　　（有点草率啊...
非旋treap（fhq treap） 指针版
denglunza622821951的博客
07-12 265
传送门 看了一圈，好像真的没什么用指针的呢。。 明明觉得指针很好看（什么？？你说RE？？？听不见听不见） 其实我觉得用数组的话不RE直接WA调起来不是更困难嘛，毕竟通过gdb还可以知道哪里RE，WA就不知道咋回事了，是不是很有道理，虽然我还是调了几小时 我写的是fhq treap，核心是split和merge操作，思想高赞dalao都讲得很清楚，我语文弱渣就不班门弄斧了，主要是想提供一个...
伸展树(Splay tree)图解与实现
热门推荐
小张的专栏
11-02 4万+
个人技术博客：http://blog.ztgreat.cn 一、伸展树    本文介绍了二叉查找树的一种改进数据结构–伸展树（Splay Tree）。它的主要特点是不会保证树一直是平衡的，但各种操作的平摊时间复杂度是O(log n)，因而，从平摊复杂度上看，二叉查找树也是一种平衡二叉树。另外，相比于其他树状数据结构（如红黑树，AVL树等），伸展树的空间要求与编程复杂度要小得多。 伸展树...
Splay(区间翻转)&树套树(Splay+线段树,90分)
weixin_30659829的博客
08-05 194
study from: https://tiger0132.blog.luogu.org/slay-notes P3369 【模板】普通平衡树 1 #include <cstdio> 2 #include <cstdlib> 3 #include <cmath> 4 #include <cstri...
动态树问题：LCT与Splay应用
LCT 建立在Splay树的基础上，但并非简单的套用Splay树的模板。Splay树本身是一种自平衡二叉搜索树，通过旋转操作保持树的平衡，但在动态树场景下，LCT需要更精细的管理，特别是对于树的链状结构（例如，重链、轻链和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值