• splay树:hdu1890

    题目链接如下所示：

    Problem - 1890

    这题可把我给整吐了，我看了大概两个下午吧，看大家说这是splay水题，是不是我不知道，但是我是真的很水。

    首先，我们得了解一下splay树，这个大家自行百度吧...

    这里有个关于区间操作的讲解或许有帮助：

    Splay处理区间操作——翻转操作(Reverse) - 笨蛋花的小窝qwq - 洛谷博客

    然后这里先介绍一下整体思路：

    1.对于一个输入的序列，按照输入的标号建立平衡二叉树

    2.把<输入值,输入顺序标号>按照输入值优先级大于顺序标号的情况，排序

    3.按照排序后的顺序，将这个点的输入顺序标号用splay操作旋转到根节点

    4.更新机械臂的旋转操作

    5.输出排序，删除根节点

    我们一点一点来说：

    1.数据结构的建立

    rev这个后面提，具体就是代表是否需要把旋转传递到下面的子树中去。

    pre就是父节点的id，size[i]代表i这个节点为根的子树的大小。

    tree用来存一个节点的左右子树的id。

    1. const int N=100010;
    2. int rev[N],pre[N],size[N];
    3. int tree[N][2];
    4. int root;
    5. struct Node{
    6.     int val;
    7.     int id;
    8.  
    9.     bool operator < (const Node &A) const{
    10.         if (val==A.val) return id
    11.         return val
    12.     }
    13. }node[N];

    2.建立平衡二叉树

    首先，怎么建立一个平衡二叉树呢，用数组的形式。其实就是用二分的方法，这里用传引用的方式直接修改子节点。代码如下所示：

    1. void newnode(int &x,int fa,int val){
    2.     x=val;
    3.     pre[x]=fa;
    4.     size[x]=1;
    5.     rev[x]=0;
    6.     tree[x][0]=tree[x][1]=0;
    7. }
    8.  
    9. void buildtree(int &x,int l,int r,int fa){
    10.     if (l>r) return;
    11.     int mid=(l+r)>>1;
    12.     newnode(x,fa,mid);
    13.     buildtree(tree[x][0],l,mid-1,x);
    14.     buildtree(tree[x][1],mid+1,r,x);
    15.     pushup(x);
    16. }
    17.  
    18. void init(int n){
    19.     root=0;
    20.     tree[root][0]=tree[root][1]=pre[root]=size[root]=0;
    21.     buildtree(root, 1, n, 0);
    22. }

    3.splay旋转

    这东西本身其实没啥困难的，无非就是把子节点旋转一下然后更新一些指向以及子树的大小，但是他引入了机械臂旋转这样一个操作，就很恶心。先看一下代码吧：

    1. void pushup(int x){
    2.     size[x]=1+size[tree[x][0]]+size[tree[x][1]];
    3. }
    4.  
    5. void update_rev(int x){
    6.     if (!x) return;
    7.     swap(tree[x][0],tree[x][1]);
    8.     rev[x]^=1;
    9. }
    10.  
    11. void pushdown(int x){
    12.     if (!rev[x]) return;
    13.     update_rev(tree[x][0]);
    14.     update_rev(tree[x][1]);
    15.     rev[x]=0;
    16. }
    17.  
    18. // c=0为左旋 1为右旋
    19. void rotate(int x,int c){
    20.     int y=pre[x];
    21.     pushdown(y);
    22.     pushdown(x);
    23.     // 原来x的子树放在y下面
    24.     tree[y][!c]=tree[x][c];
    25.     pre[tree[x][c]]=y;
    26.     // 原来y和pre[y]的指向改变
    27.     if (pre[y]){
    28.         tree[pre[y]][tree[pre[y]][1]==y]=x;
    29.     }
    30.     pre[x]=pre[y];
    31.     // 修改x和y之间的指向
    32.     tree[x][c]=y;
    33.     pre[y]=x;
    34.     pushup(y);
    35. }
    36.  
    37. void splay(int x, int goal){
    38.     pushdown(x);
    39.     while(pre[x]!=goal){
    40.         if (pre[pre[x]]==goal){
    41.             pushdown(pre[x]);
    42.             pushdown(x);
    43.             rotate(x,tree[pre[x]][0]==x);
    44.         }else{
    45.             pushdown(pre[pre[x]]);
    46.             pushdown(pre[x]);
    47.             pushdown(x);
    48.             int y=pre[x];
    49.             int c=(tree[pre[y]][0]==y);
    50.             if (tree[y][c]==x){//不共线
    51.                 rotate(x,!c);
    52.                 rotate(x,c);
    53.             }else{
    54.                 rotate(y,c);
    55.                 rotate(x,c);
    56.             }
    57.         }
    58.     }
    59.     pushup(x);
    60.     if (goal==0){
    61.         root=x;
    62.     }
    63. }

    这里边让我想了最久的就是这个pushdown，就是说这个“懒旋转”，他是这样的，每次我们不是需要把一个节点的标号对应的节点旋转到根吗，然后我们要明白，平衡二叉树的旋转并不改变中序遍历的结果，意思是他左边的子树按照中序遍历一遍那就是在他左边的序列的顺序啊！然后我们想把左边的序列全部翻转对吧，那么我们先在左子树的根上标记一下要翻转的信号，也就是先update_rev一下左子树的根，然后用pushdown传递下去，那么不就成功翻转了序列吗，因为第一次我们并没有翻转全部的序列，而是在后续操作中一步一步翻转，所以我们把这个叫做“懒旋转”捏。

    这里旋转的顺序，我们最好就是把前面的旋转完了，这样就可以有抵消的效果，来达到减少操作数的效果。

    4.删除根节点

    如果根节点无左子树，那么直接修改根节点是右子树就行。

    如果有左子树，那么找到左孩子的最右节点作为根节点，然后把这个节点旋转到根节点下面孩子的位置，修改这个节点的指向，最后把根的右子树和这个左孩子连接起来就好辣！

    代码如下所示：

    1. int get_max(int x){
    2.     pushdown(x);
    3.     while (tree[x][1]){
    4.         x=tree[x][1];
    5.         pushdown(x);
    6.     }
    7.     return x;
    8. }
    9.  
    10. void del_root(){
    11.     if (!tree[root][0]){
    12.         root=tree[root][1];
    13.         pre[root]=0;
    14.     }else{
    15.         int m=get_max(tree[root][0]);
    16.         splay(m,root);
    17.         tree[m][1]=tree[root][1];
    18.         pre[tree[root][1]]=m;
    19.         root=m;
    20.         pre[root]=0;
    21.         pushup(root);
    22.     }
    23. }

    5.合并代码

    最后代码如下所示：

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10. using namespace std;
    11.  
    12. const int N=100010;
    13. int rev[N],pre[N],size[N];
    14. int tree[N][2];
    15. int root;
    16. struct Node{
    17.     int val;
    18.     int id;
    19.  
    20.     bool operator < (const Node &A) const{
    21.         if (val==A.val) return id
    22.         return val
    23.     }
    24. }node[N];
    25.  
    26. void pushup(int x){
    27.     size[x]=1+size[tree[x][0]]+size[tree[x][1]];
    28. }
    29.  
    30. void update_rev(int x){
    31.     if (!x) return;
    32.     swap(tree[x][0],tree[x][1]);
    33.     rev[x]^=1;
    34. }
    35.  
    36. void pushdown(int x){
    37.     if (!rev[x]) return;
    38.     update_rev(tree[x][0]);
    39.     update_rev(tree[x][1]);
    40.     rev[x]=0;
    41. }
    42.  
    43. // c=0为左旋 1为右旋
    44. void rotate(int x,int c){
    45.     int y=pre[x];
    46.     pushdown(y);
    47.     pushdown(x);
    48.     // 原来x的子树放在y下面
    49.     tree[y][!c]=tree[x][c];
    50.     pre[tree[x][c]]=y;
    51.     // 原来y和pre[y]的指向改变
    52.     if (pre[y]){
    53.         tree[pre[y]][tree[pre[y]][1]==y]=x;
    54.     }
    55.     pre[x]=pre[y];
    56.     // 修改x和y之间的指向
    57.     tree[x][c]=y;
    58.     pre[y]=x;
    59.     pushup(y);
    60. }
    61.  
    62. void splay(int x, int goal){
    63.     pushdown(x);
    64.     while(pre[x]!=goal){
    65.         if (pre[pre[x]]==goal){
    66.             pushdown(pre[x]);
    67.             pushdown(x);
    68.             rotate(x,tree[pre[x]][0]==x);
    69.         }else{
    70.             pushdown(pre[pre[x]]);
    71.             pushdown(pre[x]);
    72.             pushdown(x);
    73.             int y=pre[x];
    74.             int c=(tree[pre[y]][0]==y);
    75.             if (tree[y][c]==x){//不共线
    76.                 rotate(x,!c);
    77.                 rotate(x,c);
    78.             }else{
    79.                 rotate(y,c);
    80.                 rotate(x,c);
    81.             }
    82.         }
    83.     }
    84.     pushup(x);
    85.     if (goal==0){
    86.         root=x;
    87.     }
    88. }
    89.  
    90. int get_max(int x){
    91.     pushdown(x);
    92.     while (tree[x][1]){
    93.         x=tree[x][1];
    94.         pushdown(x);
    95.     }
    96.     return x;
    97. }
    98.  
    99. void del_root(){
    100.     if (!tree[root][0]){
    101.         root=tree[root][1];
    102.         pre[root]=0;
    103.     }else{
    104.         int m=get_max(tree[root][0]);
    105.         splay(m,root);
    106.         tree[m][1]=tree[root][1];
    107.         pre[tree[root][1]]=m;
    108.         root=m;
    109.         pre[root]=0;
    110.         pushup(root);
    111.     }
    112. }
    113.  
    114. void newnode(int &x,int fa,int val){
    115.     x=val;
    116.     pre[x]=fa;
    117.     size[x]=1;
    118.     rev[x]=0;
    119.     tree[x][0]=tree[x][1]=0;
    120. }
    121.  
    122. void buildtree(int &x,int l,int r,int fa){
    123.     if (l>r) return;
    124.     int mid=(l+r)>>1;
    125.     newnode(x,fa,mid);
    126.     buildtree(tree[x][0],l,mid-1,x);
    127.     buildtree(tree[x][1],mid+1,r,x);
    128.     pushup(x);
    129. }
    130.  
    131. void init(int n){
    132.     root=0;
    133.     tree[root][0]=tree[root][1]=pre[root]=size[root]=0;
    134.     buildtree(root, 1, n, 0);
    135. }
    136.  
    137. int main()
    138. {
    139.     int n;
    140.     while (~scanf("%d",&n) && n){
    141.         init(n);
    142. //        cout<<"tree:"<
    143. //        for (int i = 1; i <= n; ++i) {
    144. //            cout<
    145. //        }
    146.         for (int i = 1; i <= n; ++i) {
    147.             scanf("%d",&node[i].val);
    148.             node[i].id=i;
    149.         }
    150.         sort(node+1,node+1+n);
    151. //        cout<<"id, val:"<
    152. //        for (int i = 1; i <= n; ++i) {
    153. //            cout<
    154. //        }
    155.         for (int i = 1; i < n; ++i) {
    156.             splay(node[i].id, 0);
    157.             update_rev(tree[root][0]);
    158.             printf("%d ", i+size[tree[root][0]]);
    159.             del_root();
    160.         }
    161.         printf("%d\n",n);
    162.     }
    163.     return 0;
    164. }

  • 相关阅读:
    如何创建一个Web项目
    c#使用ExifLib库提取图像的相机型号、光圈、快门、iso、曝光时间、焦距信息等EXIF信息
    2022-2028全球平板电脑主板行业调研及趋势分析报告
    iOS CI/CD 持续集成 组件化专题二 Cocoapods /Cocoapods Packager 问题汇总
    感知机Perceptron
    【用unity实现100个游戏之16】Unity程序化生成随机2D地牢游戏1（附项目源码）
    深入理解C++ lambda表达式：用法、特性与最佳实践
    数据库及程序日常开发命名实践【四期】
    本地 IDEA 卡死了！我把它跑在 Linux 服务器上！
    Pytest接口测试框架实战项目搭建（三）
  • 原文地址：https://blog.csdn.net/weixin_46266058/article/details/127893225