[题解]bzoj4825 HNOI2017单旋

最新推荐文章于 2019-12-29 21:30:52 发布
最新推荐文章于 2019-12-29 21:30:52 发布
阅读量439 收藏 1
点赞数
分类专栏： 数据结构 平衡树 文章标签： hnoi 数据结构 平衡树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Saramanda/article/details/77076143
版权

Description

H 国是一个热爱写代码的国家，那里的人们很小去学校学习写各种各样的数据结构。伸展树（splay）是一种数据结构，因为代码好写，功能多，效率高，掌握这种数据结构成为了 H 国的必修技能。有一天，邪恶的“卡”带着他的邪恶的“常数”来企图毁灭 H 国。“卡”给 H 国的人洗脑说，splay 如果写成单旋的，将会更快。“卡”称“单旋 splay”为“spaly”。虽说他说的很没道理，但还是有 H 国的人相信了，小 H 就是其中之一，spaly 马上成为他的信仰。 而 H 国的国王，自然不允许这样的风气蔓延，国王构造了一组数据，数据由 m 个操作构成，他知道这样的数据肯定打垮 spaly，但是国王还有很多很多其他的事情要做，所以统计每个操作所需要的实际代价的任务就交给你啦。
数据中的操作分为五种：
1. 插入操作：向当前非空 spaly 中插入一个关键码为 key 的新孤立节点。插入方法为，先让 key 和根比较，如果 key 比根小，则往左子树走，否则往右子树走，如此反复，直到某个时刻，key 比当前子树根 x 小，而 x 的左子树为空，那就让 key 成为 x 的左孩子； 或者 key 比当前子树根 x 大，而 x 的右子树为空，那就让 key 成为 x 的右孩子。该操作的代价为：插入后，key 的深度。特别地，若树为空，则直接让新节点成为一个单个节点的树。（各节点关键码互不相等。对于“深度”的解释见末尾对 spaly 的描述）。
2. 单旋最小值：将 spaly 中关键码最小的元素 xmin 单旋到根。操作代价为：单旋前 xmin 的深度。（对于单旋操作的解释见末尾对 spaly 的描述）。
3. 单旋最大值：将 spaly 中关键码最大的元素 xmax 单旋到根。操作代价为：单旋前 xmax 的深度。
4. 单旋删除最小值：先执行 2 号操作,然后把根删除。由于 2 号操作之后,根没有左子树,所以直接切断根和右子树的联系即可（具体见样例解释）。 操作代价同 2 号操 作。
5. 单旋删除最大值：先执行 3 号操作,然后把根删除。 操作代价同 3 号操作。对于不是 H 国的人，你可能需要了解一些 spaly 的知识，才能完成国王的任务：
a. spaly 是一棵二叉树，满足对于任意一个节点 x，它如果有左孩子 lx，那么 lx 的关键码小于 x 的关键码。如果有右孩子 rx，那么 rx 的关键码大于 x 的关键码。
b. 一个节点在 spaly 的深度定义为：从根节点到该节点的路径上一共有多少个节点（包括自己）。
c. 单旋操作是对于一棵树上的节点 x 来说的。一开始,设 f 为 x 在树上的父亲。如果 x 为 f 的左孩子，那么执行 zig(x) 操作（如上图中，左边的树经过 zig(x) 变为了右边的树），否则执行 zag(x) 操作（在上图中，将
右边的树经过 zag(f) 就变成了左边的树）。每当执 行一次 zig(x) 或者 zag(x)，x 的深度减小 1，如此反复，直到 x 为根。总之，单旋 x 就是通过反复执行 zig 和 zag 将 x 变为根。

Input

第一行单独一个正整数 m。
接下来 m 行，每行描述一个操作：首先是一个操作编号 c∈[1,5]，即问题描述中给出的五种操作中的编号，若 c = 1，则再输入一个非负整数 key，表示新插入节点的关键码。1≤m≤10^5,1≤key≤10^9
所有出现的关键码互不相同。任何一个非插入操作，一定保证树非空。在未执行任何操作之前，树为空

Output

输出共 m 行，每行一个整数，第 i 行对应第 i 个输入的操作的代价。

Sample Input

5
1 2
1 1
1 3
4
5

Sample Output

1
2
2
2
2

Solution

单旋的时候对树的形态破坏不大，只会影响少数节点，所以用Splay维护深度就好了，自己手动分析一下影响，同时记录下在真正的Spaly树上的父亲、左右儿子。细节多如牛毛，真心难调。

代码:

#include<cstdio>
#include<algorithm>
using namespace std;

template<typename T>inline void read(T &x){
    T f=1;char ch=getchar();
    for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
    for(x=0;ch>='0'&&ch<='9';ch=getchar())x=x*10+ch-'0';
    x*=f;
}

const int maxn=100010,inf=0x7fffffff;
struct node{
    int ch[2],fa,key,dep,add,rfa,rch[2];
    node(){
        ch[0]=ch[1]=rch[0]=rch[1]=0;
        rfa=fa=key=dep=add=0;
    }
}T[maxn];
struct Splay_Tree{
    int root,num,rroot;
    Splay_Tree(){rroot=root=num=0;}
    int getson(int x){
        return x==T[T[x].fa].ch[1];
    }
    void pushdown(int x){
        if(!T[x].add)return;
        if(T[x].ch[0]){
            T[T[x].ch[0]].add+=T[x].add;
            T[T[x].ch[0]].dep+=T[x].add;
        }
        if(T[x].ch[1]){
            T[T[x].ch[1]].add+=T[x].add;
            T[T[x].ch[1]].dep+=T[x].add;
        }
        T[x].add=0;
    }
    void rotate(int x){
        int fa=T[x].fa,fafa=T[fa].fa,k=getson(x);
        pushdown(fa);pushdown(x);
        T[fa].ch[k]=T[x].ch[k^1];
        if(T[x].ch[k^1])T[T[x].ch[k^1]].fa=fa;
        T[x].ch[k^1]=fa;T[fa].fa=x;T[x].fa=fafa;
        if(fafa)T[fafa].ch[fa==T[fafa].ch[1]]=x;
    }
    void Splay(int x,int f=0){
        for(int fa;(fa=T[x].fa)!=f;rotate(x))
            if(T[fa].fa!=f)rotate(getson(x)==getson(fa)?fa:x);
        if(!f)root=x;
    }
    void Insert(int val,int dp){
        if(!root){
            T[root=++num].key=val;
            T[root].dep=dp;rroot=num;
            return;
        }
        int x=root,fa;
        while(x){
            pushdown(fa=x);
            x=T[x].ch[val>T[x].key];
        }
        T[fa].ch[val>T[fa].key]=++num;
        T[num].key=val;T[num].dep=dp;
        T[num].fa=fa;
        Splay(num);
    }
    int Find(int val){
        int x=root;
        while(1){
            pushdown(x);
            if(T[x].key==val)return x;
            x=T[x].ch[val>T[x].key];
        }
    }
    int Getpre(int val){
        int x=root,ans=-inf;
        while(x){
            pushdown(x);
            if(T[x].key<val)ans=x,x=T[x].ch[1];
            else x=T[x].ch[0];
        }
        return ans;
    }
    int Getsuf(int val){
        int x=root,ans=inf;
        while(x){
            pushdown(x);
            if(T[x].key>val)ans=x,x=T[x].ch[0];
            else x=T[x].ch[1];
        }
        return ans;
    }
    int Getmin(){
        int x=root;
        while(T[x].ch[0])pushdown(x),x=T[x].ch[0];
        return x;
    }
    int Getmax(){
        int x=root;
        while(T[x].ch[1])pushdown(x),x=T[x].ch[1];
        return x;
    }
}tree;
int n;

int main(){
    read(n);
    while(n--){
        int opt,x,ans;
        read(opt);
        if(opt==1){
            read(x);
            int l=tree.Getpre(x);
            int r=tree.Getsuf(x);
            if(l<0&&r==inf)tree.Insert(x,ans=1);
            else if(l<0){
                tree.Insert(x,ans=T[r].dep+1);
                T[T[r].rch[0]=tree.num].rfa=r;
            }
            else if(r==inf){
                tree.Insert(x,ans=T[l].dep+1);
                T[T[l].rch[1]=tree.num].rfa=l;
            }
            else{
                if(T[l].dep>T[r].dep){
                    tree.Insert(x,ans=T[l].dep+1);
                    T[T[l].rch[1]=tree.num].rfa=l;
                }
                else{
                    tree.Insert(x,ans=T[r].dep+1);
                    T[T[r].rch[0]=tree.num].rfa=r;
                }
            }
        }
        else if(opt==2){
            x=tree.Getmin();ans=T[x].dep;
            T[x].dep=1;tree.Splay(x);
            if(T[x].rfa){
                if(T[x].ch[1]){
                    T[T[x].ch[1]].add++;
                    T[T[x].ch[1]].dep++;
                }
                if(T[x].rch[1]){
                    int temp=T[x].rch[1];
                    T[temp].rfa=T[x].rfa;
                    T[T[x].rfa].rch[0]=temp;
                    tree.Splay(T[x].rfa,x);
                    T[T[T[x].rfa].ch[0]].add--;
                    T[T[T[x].rfa].ch[0]].dep--;
                }
                else T[T[x].rfa].rch[0]=0;
                T[x].rch[1]=tree.rroot;
                T[tree.rroot].rfa=x;
                T[x].rfa=T[x].rch[0]=0;
                tree.rroot=x;
            }
        }
        else if(opt==3){
            x=tree.Getmax();ans=T[x].dep;
            T[x].dep=1;tree.Splay(x);
            if(T[x].rfa){
                if(T[x].ch[0]){
                    T[T[x].ch[0]].add++;
                    T[T[x].ch[0]].dep++;
                }
                if(T[x].rch[0]){
                    int temp=T[x].rch[0];
                    T[temp].rfa=T[x].rfa;
                    T[T[x].rfa].rch[1]=temp;
                    tree.Splay(T[x].rfa,x);
                    T[T[T[x].rfa].ch[1]].add--;
                    T[T[T[x].rfa].ch[1]].dep--;
                }
                else T[T[x].rfa].rch[1]=0;
                T[x].rch[0]=tree.rroot;
                T[tree.rroot].rfa=x;
                T[x].rfa=T[x].rch[1]=0;
                tree.rroot=x;
            }
        }
        else if(opt==4){
            x=tree.Getmin();ans=T[x].dep;
            T[x].dep=1;tree.Splay(x);
            if(T[x].rfa){
                if(T[x].ch[1]){
                    T[T[x].ch[1]].add++;
                    T[T[x].ch[1]].dep++;
                }
                if(T[x].rch[1]){
                    int temp=T[x].rch[1];
                    T[temp].rfa=T[x].rfa;
                    T[T[x].rfa].rch[0]=temp;
                    tree.Splay(T[x].rfa,x);
                    T[T[T[x].rfa].ch[0]].add--;
                    T[T[T[x].rfa].ch[0]].dep--;
                }
                else T[T[x].rfa].rch[0]=0;
                T[x].rch[1]=tree.rroot;
                T[tree.rroot].rfa=x;
                T[x].rfa=T[x].rch[0]=0;
                tree.rroot=x;
            }
            tree.pushdown(tree.root);
            tree.rroot=T[tree.rroot].rch[1];
            T[tree.rroot].rfa=0;
            tree.root=T[tree.root].ch[1];
            T[tree.root].fa=0;
            if(tree.root){
                T[tree.root].add--;
                T[tree.root].dep--;
            }
        }
        else if(opt==5){
            x=tree.Getmax();ans=T[x].dep;
            T[x].dep=1;tree.Splay(x);
            if(T[x].rfa){
                if(T[x].ch[0]){
                    T[T[x].ch[0]].add++;
                    T[T[x].ch[0]].dep++;
                }
                if(T[x].rch[0]){
                    int temp=T[x].rch[0];
                    T[temp].rfa=T[x].rfa;
                    T[T[x].rfa].rch[1]=temp;
                    tree.Splay(T[x].rfa,x);
                    T[T[T[x].rfa].ch[1]].add--;
                    T[T[T[x].rfa].ch[1]].dep--;
                }
                else T[T[x].rfa].rch[1]=0;
                T[x].rch[0]=tree.rroot;
                T[tree.rroot].rfa=x;
                T[x].rfa=T[x].rch[1]=0;
                tree.rroot=x;
            }
            tree.pushdown(tree.root);
            tree.rroot=T[tree.rroot].rch[0];
            T[tree.rroot].rfa=0;
            tree.root=T[tree.root].ch[0];
            T[tree.root].fa=0;
            if(tree.root){
                T[tree.root].add--;
                T[tree.root].dep--;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}
Saramanda
关注
专栏目录
[HNOI2017]单旋
待成熟的葡萄
04-19 839
题目大意你需要维护一个spaly，这个数据结构在将节点旋转到根只会一直单旋自己。 有qq个操作，你需要对每一个操作都输出其时间代价，操作有如下几种： ∙ \bullet\ 插入操作：插入一个关键字为xx的点，插入方法是正常的二叉查找树的插入，时间代价是插入位置的深度。（注意：不要因为平时打的splay想当然地认为这个操作在执行完之后会将插入点旋转到根） ∙ \bullet\ 单旋最小值：将sp
[题解]bzoj2730(HNOI2012)矿场搭建
Saramanda的博客
02-23 674
Description 煤矿工地可以看成是由隧道连接挖煤点组成的无向图。为安全起见，希望在工地发生事故时所有挖煤点的工人都能有一条出路逃到救援出口处。于是矿主决定在某些挖煤点设立救援出口，使得无论哪一个挖煤点坍塌之后，其他挖煤点的工人都有一条道路通向救援出口。请写一个程序，用来计算至少需要设置几个救援出口，以及不同最少救援出口的设置方案总数。 Input 输入文件有若干组数据，每
BZOJ4825: [Hnoi2017]单旋
wxh010910
04-23 665
Description H 国是一个热爱写代码的国家，那里的人们很小去学校学习写各种各样的数据结构。伸展树（splay）是一种数据 结构，因为代码好写，功能多，效率高，掌握这种数据结构成为了 H 国的必修技能。有一天，邪恶的“卡”带着 他的邪恶的“常数”来企图毁灭 H 国。“卡”给 H 国的人洗脑说，splay 如果写成单旋的，将会更快。“卡”称 “单旋 splay”为“spaly”。
「AHOI / HNOI2017」单旋
weixin_33874713的博客
03-13 206
「AHOI / HNOI2017」单旋 题目链接 H 国是一个热爱写代码的国家，那里的人们很小去学校学习写各种各样的数据结构。伸展树（splay）是一种数据结构，因为代码好写，功能多，效率高，掌握这种数据结构成为了 H 国的必修技能。有一天，邪恶的「卡」带着他的邪恶的「常数」来企图毁灭 H 国。「卡」给 H 国的人洗脑说，splay 如果写成单旋的，将会更快。「卡」称「单旋 splay」为「spa...
[BZOJ4825][HNOI2017]单旋 平衡树
HbFS-
04-19 741
诶这题有一万种做法 按key值从小到大排序，对每一位维护他的深度 将一个点旋到根，相当于他所在的子树里的深度不变，剩余平衡树链接在这个点下面 用Treap维护这个序列 对于插入操作：查询key值的前驱和后继，取较大值+1作为改点的新深度 对于查询最小值操作：寻找序列第一个深度小于最小值所在节点的深度的那个点，这个点即为待旋节点的父亲，这个区间的深度不变，剩余区间的深度做区间加法，再特殊处理
[spaly模拟 线段树] BZOJ 4825 [Hnoi2017]单旋
雯舞
04-20 1053
发现旋最小值到根 最小值深度变为1 他的右子树深度不变 其他都加1 旋最大值类似 这个只要线段树就好了 怎么求子树 看他的father 插入操作 找出前驱和后继 一定是祖先子孙关系 新点往深度大的下面挂#include<cstdio> #include<cstdlib> #include<algorithm> #include<set> using namespace std;inline ch
bzoj1008: [HNOI2008]越狱 题解
Unlimited的博客
01-08 604
1008: [HNOI2008]越狱 Description 　　监狱有连续编号为1…N的N个房间，每个房间关押一个犯人，有M种宗教，每个犯人可能信仰其中一种。如果 相邻房间的犯人的宗教相同，就可能发生越狱，求有多少种状态可能发生越狱 Input 　　输入两个整数M，N.1&amp;lt;=M&amp;lt;=10^8,1&amp;lt;=N&amp;lt;=10^12 Output 　　...
bzoj 4542 洛谷 3245 [HNOI]2016大数 题解
LightningUZ的博客
12-29 254
博客观赏效果更佳 题意简述 给你一个数字字符串SSS，长度为n<=1e5n<=1e5n<=1e5。有一个intintint范围内的质数PPP和Q<=1e5Q<=1e5Q<=1e5次询问，每次询问一个区间[l,r][l,r][l,r]中，SSS的多少个子串（不一定不同）是PPP的倍数。 比如S="007"S="007"S="007"，它有6个子串，分别是{0,0,...
bzoj 4010: [HNOI2015]菜肴制作
Unlimited的博客
03-22 393
bzoj 4010: [HNOI2015]菜肴制作 Description 知名美食家小 A被邀请至ATM 大酒店，为其品评菜肴。 ATM 酒店为小 A 准备了 N 道菜肴，酒店按照为菜肴预估的质量从高到低给予1到N的顺序编号，预估质量最高的菜肴编号为1。由于菜肴之间口味搭配的问题，某些菜肴必须在另一些菜肴之前制作，具体的，一共有 M 条形如“i 号菜肴‘必须’先于 j 号菜肴制...
BZOJ1225 [HNOI2001]求正整数
huzecong的博客
01-07 2456
BZOJ1225题解 （CSDN公式会蛋疼……于是只能贴图……） Code DP： //BZOJ1225; 求正整数 (HNOI2001); DP //SGU475; Droid Fromation; #include #include #include #include #define N 50000 #define LOGN 15 #define SIZE 10000
BZOJ4825 [Hnoi2017]单旋
neither_nor
04-17 1812
HNOID1每道题都已小于2s的差距领先ljss交到BZ上23333 论快捷键提交的优越性 考虑一次插入了x，x的前驱为pre，后继为nxt，平衡树中排名相邻的两个点一定互为祖先关系，那么如果pre为nxt的祖先，x就插入到了nxt的左儿子，如果nxt为pre的祖先，x就插入到了pre的右儿子 考虑把最小值旋到根的操作，最小值没有左子树，最小值的右子树变成了最小值父亲的左子树，根变成了最小值
【BZOJ4825】【HNOI2017】单旋（线段树，set）
დ♂Hany01's Blog Space♂ღ
04-06 200
Description click me Solution 手玩发现每次去最大、最小值也就是直接将该节点放到根节点，插入值就是将节点插入到该键值的前驱后继中深度最大的那个的下方。 然后用std::set维护深度，用，线段树维护深度即可。 Code /************************************** * Au: Hany01 * Prob:...
[BZOJ4825][Hnoi2017]单旋（LCT+set）
女装的你，如此好看！
01-05 324
手动模拟，可以发现：单旋最小值或最大值到根，实际上就是删掉了22条边又加上了22条边。 而对于维护深度，由于根节点不断变化，所以树中所有节点的深度也在不断地整体变化。因此考虑用一个LCT维护这棵树，这样查询一个节点的深度，就是查询一个点到根的距离。同时又能支持动态加边和删边。 所以，现在就剩下一个问题：如何确定新节点的位置。 以下，设xx为待插入的节点，vxv_x为节点xx的关键码（这里xx
bzoj4825/洛谷P3721 单旋 splay
litble的成(tui)长(fei)史
03-15 364
题目分析 有人问起我学会的第一个高级数据结构是什么。 我说是spaly。 在HNOI2017的考场上学会的。 俗话说的好，双旋的splay，单旋的spaly，不旋的saply，O(1)的asply，那么我们就来用splay做一做这道题。 首先我们手模一发单旋最小值操作。会发现，假如最小值节点是x，那么这个操作就是把x放到根，x的右子树给他原来的父亲当左子树，把原来的根节点给它做右子树。 ...
[bzoj4825][Hnoi2017]单旋
WorldWide_D的博客
04-19 1638
题目大意有五种操作：给spaly插入一个数、把最小（或最大）值旋转到根（插入后不旋转）、把最小（或最大）值旋转到根后删除。每次操作输出对应节点在spaly中的深度。由于是spaly，操作是单旋的。 操作次数n≤100000，所有数互不相同分析首先是插入操作。容易发现，节点的深度是当前spaly中比它小中最大的、比它大的中最小的，两个节点深度更大值+1。 接下来是旋转&删除。旋转最小、大值的思路类
【BZOJ4825】单旋（AHOI&HNOI2017）-set+树状数组
Maxwei_wzj的OI世界
05-11 363
测试地址：单旋 做法：本题需要用到set+树状数组。 首先，我们注意到题目中单旋只涉及到最小值和最大值，考虑到旋转是对称的，我们先只考虑单旋最小值的情况。 显然目标点每次都是往右旋转，往右旋转对点的影响是：该点的右子树深度没有影响，该点深度减少111，而对于其它影响到的点深度都增加111。那么我们可以得到一个非常优美的性质：每一次单旋，除了以目标点为根的子树外，其它所有点深度都增加111。并...
LCT（Link-Cut Tree）详解（蒟蒻自留地）
热门推荐
Saramanda的博客
02-16 2万+
最近自学了LCT，发现网上的资料讲解不是很全面，像我这样的蒟蒻一时半会根本理解不了。我弄了很久总算是理解了LCT，打算总结一下LCT的基本操作，还请诸位神牛来找找茬。   如果你还没有接触过LCT，你可以先看一看这里： （看不懂没关系，先留个大概的印像）http://www.cnblogs.com/BLADEVIL/p/3510997.html 看完之后我们知道，LCT和静态的树链剖分很像
[题解]bzoj2049(SDOI2008)Cave 洞穴勘探
Saramanda的博客
02-15 1666
Description 辉辉热衷于洞穴勘测。某天，他按照地图来到了一片被标记为JSZX的洞穴群地区。经过初步勘测，辉辉发现这片区域由n个洞穴（分别编号为1到n）以及若干通道组成，并且每条通道连接了恰好两个洞穴。假如两个洞穴可以通过一条或者多条通道按一定顺序连接起来，那么这两个洞穴就是连通的，按顺序连接在一起的这些通道则被称之为这两个洞穴之间的一条路径。洞穴都十分坚固无法破坏，然而通道不太稳定
OpenJudge题解与ACM编程资源分享
资源摘要信息:"程序设计与算法一OpenJudge题解-ACM资源" 本资源是一套与OpenJudge平台相关的ACM（American College of Management）题解集，专门针对程序设计和算法的初学者。OpenJudge是一个在线编程评测系统，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值