题目

  点这里看题目。

分析

  最妙的地方在于,这道题其实是用一种数据结构模拟另一种数据结构

  我们需要维护深度和树的结构,以下对于每个操作进行分别讨论。

插入一个新节点

  可以发现,这个新节点一定会成为自己的前驱或者后继中深度较大者的儿子

  然后可以更新深度和树的结构。

单旋最小值

  发现树会有如下的变化:

    如果自己有儿子,那么它只会是自己的右儿子;旋转后,它会接到自己原先的父亲上

    除了自己的儿子以外,其它的节点的深度都会 +1

    
原先的根变成了最小值的儿子
根随后变成最小值

  单旋最大值同理分析。

单旋最小值并删除

  先模拟好单旋的修改,然后考虑旋转后的变化:

    所有节点深度 -1

    
断开最小值和它的右儿子的边,根变为它的右儿子


  单旋最大值并删除同理分析。

  发现树的深度的修改实际上可以理解为值域上一段区间的加减,因此可以用权值线段树维护;前驱后继也可以顺便用它维护了。

  中途我们需要用 map 来维护树的形态,或者离散化之后直接存下来也可以。

  时间复杂度:\(O(n\log_2|V|)\)。

代码

#include <map>
#include <cstdio>
using namespace std; const int up = 1e9/*4*/;
const int MAXN = 1e5 + 5, MAXLOG = 30, MAXS = MAXN * MAXLOG/*205*/; template<typename _T>
void read( _T &x )
{
x = 0;char s = getchar();int f = 1;
while( s > '9' || s < '0' ){if( s == '-' ) f = -1; s = getchar();}
while( s >= '0' && s <= '9' ){x = ( x << 3 ) + ( x << 1 ) + ( s - '0' ), s = getchar();}
x *= f;
} template<typename _T>
void write( _T x )
{
if( x < 0 ){ putchar( '-' ); x = ( ~ x ) + 1; }
if( 9 < x ){ write( x / 10 ); }
putchar( x % 10 + '0' );
} map<int, int> fa, ch[2]; int siz[MAXS], dep[MAXS], tag[MAXS], lch[MAXS], rch[MAXS];
int tot, rt, sgrt; void upt( const int x ) { siz[x] = siz[lch[x]] + siz[rch[x]]; }
void add( const int x, const int v ) { dep[x] += siz[x] * v, tag[x] += v; }
void normalize( const int x ) { if( tag[x] ) add( lch[x], tag[x] ), add( rch[x], tag[x] ), tag[x] = 0; } void setNode( int &u, const int l, const int r, const int pos, const int v )
{
if( ! u ) u = ++ tot;
if( l == r ) { siz[u] += v; return ; }
int mid = l + r >> 1; normalize( u );
if( pos <= mid ) setNode( lch[u], l, mid, pos, v );
else setNode( rch[u], mid + 1, r, pos, v );
upt( u );
} void update( int &u, const int l, const int r, const int segL, const int segR, const int v )
{
if( ! u ) u = ++ tot;
if( segL <= l && r <= segR ) { add( u, v ); return ; }
int mid = l + r >> 1; normalize( u );
if( segL <= mid ) update( lch[u], l, mid, segL, segR, v );
if( mid < segR ) update( rch[u], mid + 1, r, segL, segR, v );
upt( u );
} int query( const int u, const int l, const int r, const int segL, const int segR )
{
if( ! u ) return 0;
if( segL <= l && r <= segR ) return siz[u];
int mid = l + r >> 1, ret = 0; normalize( u );
if( segL <= mid ) ret += query( lch[u], l, mid, segL, segR );
if( mid < segR ) ret += query( rch[u], mid + 1, r, segL, segR );
return ret;
} int Kth( const int u, const int l, const int r, const int rnk )
{
if( l == r ) return l;
int mid = l + r >> 1; normalize( u );
if( rnk <= siz[lch[u]] ) return Kth( lch[u], l, mid, rnk );
return Kth( rch[u], mid + 1, r, rnk - siz[lch[u]] );
} int getDep( const int u, const int l, const int r, const int pos )
{
if( l == r ) return dep[u];
int mid = l + r >> 1; normalize( u );
if( pos <= mid ) return getDep( lch[u], l, mid, pos );
return getDep( rch[u], mid + 1, r, pos );
} int Kth( const int rnk ) { if( rnk <= 0 ) return -1; if( rnk > siz[sgrt] ) return up + 1; return Kth( sgrt, 1, up, rnk ); }
int getDep( const int id ) { if( id < 0 || id > up ) return -0x3f3f3f3f; return getDep( sgrt, 1, up, id ); } int getMx( const int u, const int l, const int r )
{
if( l == r ) return l;
int mid = l + r >> 1; normalize( u );
if( siz[rch[u]] ) return getMx( rch[u], mid + 1, r );
return getMx( lch[u], l, mid );
} int getMn( const int u, const int l, const int r )
{
if( l == r ) return l;
int mid = l + r >> 1; normalize( u );
if( siz[lch[u]] ) return getMn( lch[u], l, mid );
return getMn( rch[u], mid + 1, r );
} int rotMn()
{
int id = getMn( sgrt, 1, up ), rig = ch[1][id], y = fa[id];
if( rt == id ) return 1;
if( rig ) fa[rig] = y; fa[rt] = id, fa[id] = 0;
ch[1][id] = rt, ch[0][y] = rig, rt = id;
int ret = getDep( id );
update( sgrt, 1, up, y, up, 1 );
update( sgrt, 1, up, id, id, -ret + 1 );
return ret;
} int rotMx()
{
int id = getMx( sgrt, 1, up ), lef = ch[0][id], y = fa[id];
if( rt == id ) return 1;
if( lef ) fa[lef] = y; fa[rt] = id, fa[id] = 0;
ch[0][id] = rt, ch[1][y] = lef, rt = id;
int ret = getDep( id );
update( sgrt, 1, up, 1, y, 1 );
update( sgrt, 1, up, id, id, -ret + 1 );
return ret;
} int main()
{
int op, k, N;
read( N );
while( N -- )
{
read( op );
if( op == 1 )
{
read( k ), setNode( sgrt, 1, up, k, 1 );
if( siz[1] == 1 )
{
fa[rt = k] = 0, update( sgrt, 1, up, k, k, 1 );
puts( "1" );
continue;
}
int rnk = query( sgrt, 1, up, 1, k );
int pre = Kth( rnk - 1 ), suf = Kth( rnk + 1 );
int dpre = getDep( pre ), dsuf = getDep( suf );
if( dpre > dsuf ) fa[k] = pre, ch[1][pre] = k, update( sgrt, 1, up, k, k, dpre + 1 );
else fa[k] = suf, ch[0][suf] = k, update( sgrt, 1, up, k, k, dsuf + 1 );
write( getDep( k ) ), putchar( '\n' );
}
if( op == 2 ) write( rotMn() ), putchar( '\n' );
if( op == 3 ) write( rotMx() ), putchar( '\n' );
if( op == 4 )
{
int ans = rotMn(), tmp = rt, y = ch[1][tmp];
update( sgrt, 1, up, tmp + 1, up, -1 );
update( sgrt, 1, up, tmp, tmp, - ans );
if( y ) fa[y] = 0; ch[1][tmp] = 0, rt = y;
setNode( sgrt, 1, up, tmp, -1 );
write( ans ), putchar( '\n' );
}
if( op == 5 )
{
int ans = rotMx(), tmp = rt, y = ch[0][tmp];
update( sgrt, 1, up, 1, tmp - 1, -1 );
update( sgrt, 1, up, tmp, tmp, -ans );
if( y ) fa[y] = 0; ch[0][tmp] = 0, rt = y;
setNode( sgrt, 1, up, tmp, -1 );
write( ans ), putchar( '\n' );
}
}
return 0;
}

[AHOI2017/HNOI2017]单旋的更多相关文章

  1. bzoj 4825: [Hnoi2017]单旋 [lct]

    4825: [Hnoi2017]单旋 题意:有趣的spaly hnoi2017刚出来我就去做,当时这题作死用了ett,调了5节课没做出来然后发现好像直接用lct就行了然后弃掉了... md用lct不知 ...

  2. 【LG3721】[HNOI2017]单旋

    [LG3721][HNOI2017]单旋 题面 洛谷 题解 20pts 直接模拟\(spaly\)的过程即可. 100pts 可以发现单旋最大.最小值到根,手玩是有显然规律的,发现只需要几次\(lin ...

  3. 4825: [Hnoi2017]单旋

    4825: [Hnoi2017]单旋 链接 分析: 以后采取更保险的方式写代码!!!81行本来以为不特判也可以,然后就总是比答案大1,甚至出现负数,调啊调啊调啊调~~~ 只会旋转最大值和最小值,以最小 ...

  4. [BZOJ4825][HNOI2017]单旋(线段树+Splay)

    4825: [Hnoi2017]单旋 Time Limit: 10 Sec  Memory Limit: 256 MBSubmit: 667  Solved: 342[Submit][Status][ ...

  5. 【BZOJ4825】[Hnoi2017]单旋 线段树+set

    [BZOJ4825][Hnoi2017]单旋 Description H 国是一个热爱写代码的国家,那里的人们很小去学校学习写各种各样的数据结构.伸展树(splay)是一种数据结构,因为代码好写,功能 ...

  6. bzoj4825 [Hnoi2017]单旋

    Description H 国是一个热爱写代码的国家,那里的人们很小去学校学习写各种各样的数据结构.伸展树(splay)是一种数据结构,因为代码好写,功能多,效率高,掌握这种数据结构成为了 H 国的必 ...

  7. BZOJ:4825: [Hnoi2017]单旋

    Description H 国是一个热爱写代码的国家,那里的人们很小去学校学习写各种各样的数据结构.伸展树(splay)是一种数据结构,因为代码好写,功能多,效率高,掌握这种数据结构成为了 H 国的必 ...

  8. HNOI2017 单旋

    题目描述 网址:https://www.luogu.org/problemnew/show/3721 大意: 有一颗单旋Splay(Spaly),以key值为优先度,总共有5个操作. [1] 插入一个 ...

  9. HNOI2017单旋

    单旋 这道题做法贼多,LCT,splay,线段树什么的貌似都行. 像我这种渣渣只会线段树了(高级数据结构学了也不会用). 首先离线所有操作,因为不会有两个点值重复,所以直接离散. 一颗线段树来维护所有 ...

随机推荐

  1. 【K8S】基于Docker+K8S+GitLab/SVN+Jenkins+Harbor搭建持续集成交付环境(环境搭建篇)

    写在前面 最近在 K8S 1.18.2 版本的集群上搭建DevOps环境,期间遇到了各种坑.目前,搭建环境的过程中出现的各种坑均已被填平,特此记录,并分享给大家! 服务器规划 IP 主机名 节点 操作 ...

  2. CPU上下文切换以及相关指标的理解

      前言 上下文切换这个词一直不理解,看了无数遍就忘了无数遍,知道看到<操作系统导论>这本书,终于有了略微的理解.这也证明了我的方向是没错的,一直认为做运维还是得理解底层的知识,不理解很多 ...

  3. 阿里短信回持.net sdk的bug导致生产服务cpu 100%排查

    一:背景 1. 讲故事 去年阿里聚石塔上的所有isv短信通道全部对接阿里通信,我们就做了对接改造,使用阿里提供的.net sdk. 网址:https://help.aliyun.com/documen ...

  4. [工具推荐]002.SoftOrbits Sketch Drawer使用教程

    SoftOrbits Sketch Drawer是一款简单易用的照片素描化软件,内置多种预设方案以及丰富的自定义细节. 只需要一次轻轻的鼠标点击,就可以帮助你迅速的将家人的照片转换为黑白或者彩色的素描 ...

  5. [Objective-C] 006_Protocol(协议)

    学过java的同学都知道Interface(接口),那么在Objective-C中有没有接口呢?其实 Objective-C中用Protocol(协议)来实现的,在Objective-C具体怎么用,我 ...

  6. SpringBoot—自定义线程池及并发定时任务模板

    介绍   在项目开发中,经常遇到定时任务,今天通过自定义多线程池总结一下SpringBoot默认实现的定时任务机制. 定时任务模板 pom依赖 <dependencies> <dep ...

  7. Java IO(十四) CharArrayReader 和 CharArrayWriter

    Java IO(十四) CharArrayReader 和 CharArrayWriter 一.介绍 CharArrayReader 和 CharArrayWriter 是字符数组输入流和字符数组输出 ...

  8. Python编程基本规范

    1.命名规范 类:类的名称一般为名词,且以驼峰形式(即每个单词首字母要大写,其余字母小写,单词之间无间隔符号)给出. 函数:一般以动词开头,函数名称要准确.简要地概括本函数的作用.函数名一律小写,如有 ...

  9. STM32读取Guidance数据——Guidance SDK

    更新记录:2019/11/14    更新STM32(F407VET6)读取Guidance数据 Github地址. 背景:想要将祖传的Guidance用于DJI A3/新固件的N3飞控.DJI已经停 ...

  10. Matlab矩阵学习三 矩阵的运算

    Matlab矩阵的运算 一.矩阵的加减 在matlab中,矩阵的加减和数的加减符号一样,都是"+"和”-“,不同的是两个进行运算的矩阵维度必须相同  二.数乘  三.乘法 矩阵乘法 ...