HNOI2017 单旋

题解

可以发现，每次单旋最大或者最小值的时候其实就是一个简单的Link/Cut的过程。所以可以用LCT维护树的形态。
现在的问题是如何处理插入操作。仔细观察可以发现，对于当前这个插入的权值为$x$的点，设当前存在的权值恰好比$x$小的点为$a$，当前存在的权值恰好比$x$大的点为$b$。那么当前这个插入的点最后一定是$a,b$中深度较大的点的儿子。这个可以用一个set维护。

时间复杂度：$O(nlogn)$

SRC

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<set>
using namespace std ;

#define N 100000 + 10
typedef pair < int , int > PAIR ;

set < PAIR > Q ;

bool Rev[N] ;
int Pre[N] , Son[N][2] , Size[N] , D[N] , key[N] ;
int fa[N] , TSon[N][2] ;
int m , ans , Cnt , Root ;

bool IsRoot( int x ) { return Son[Pre[x]][0] != x && Son[Pre[x]][1] != x ; }

void Push( int x ) {
    if ( !Rev[x] ) return ;
    swap( Son[x][0] , Son[x][1] ) ;
    Rev[Son[x][0]] ^= 1 , Rev[Son[x][1]] ^= 1 ;
    Rev[x] = 0 ;
}

void Update( int x ) {
    Size[x] = Size[Son[x][0]] + Size[Son[x][1]] + 1 ;
}

void Rotate( int x ) {
    int F = Pre[x] , G = Pre[F] ;
    int Side = (Son[F][1] == x) ;
    if ( !IsRoot(F) ) Son[G][Son[G][1] == F] = x ;
    Pre[F] = x , Pre[x] = G ;
    Son[F][Side] = Son[x][!Side] ;
    Pre[Son[x][!Side]] = F ;
    Son[x][!Side] = F ;
    Update(F) ;
    Update(x) ;
}

void Splay( int x ) {
    D[D[0] = 1] = x ;
    for (int p = x ; !IsRoot(p) ; p = Pre[p] ) D[++D[0]] = Pre[p] ;
    for (int i = D[0] ; i ; i -- ) Push(D[i]) ;
    while ( !IsRoot(x) ) {
        int y = Pre[x] , z = Pre[y] ;
        if ( !IsRoot(y) ) {
            if ( (Son[y][0] == x) ^ (Son[z][0] == y) ) Rotate(x) ;
            else Rotate(y) ;
        }
        Rotate(x) ;
    }
    Update(x) ;
}

void Access( int x ) {
    int last = 0 ;
    while ( x ) {
        Splay(x) ;
        Son[x][1] = last ;
        last = x ;
        x = Pre[x] ;
    }
}

void MakeRoot( int x ) {
    Access(x) ;
    Splay(x) ;
    Rev[x] ^= 1 ;
}

int CalcDeep( int x ) {
    if ( !x ) return 0 ;
    MakeRoot(Root) ;
    Access(x) ;
    Splay(x) ;
    return Size[x] ;
}

void Link( PAIR x , PAIR y ) {
    MakeRoot( y.second ) ;
    Pre[y.second] = x.second ;
    fa[y.second] = x.second ;
    if ( y.first < x.first ) TSon[x.second][0] = y.second ;
    else TSon[x.second][1] = y.second ;
}

void Cut( PAIR x , PAIR y ) {
    MakeRoot(x.second) ;
    Access(y.second) ;
    Splay(y.second) ;
    Pre[x.second] = Son[y.second][0] = 0 ;
    fa[y.second] = 0 ;
    if ( y.first < x.first ) TSon[x.second][0] = 0 ;
    else TSon[x.second][1] = 0 ;
}

void Insert( int x ) {
    ++ Cnt ;
    key[Cnt] = x ;
    if ( !Root ) {
        ans = 1 ;
        Root = Cnt ;
        Size[Cnt] = 1 ;
        PAIR ins = make_pair( x , Cnt ) ;
        Q.insert( ins ) ;
        return ;
    }
    PAIR tmp = make_pair( x , 0 ) ;
    set < PAIR > :: iterator it = Q.lower_bound( tmp ) ;
    PAIR a = make_pair( 0 , 0 ) , b = make_pair( 0 , 0 ) ;
    if ( it != Q.end() ) a = *it ;
    if ( it != Q.begin() ) {
        it -- ;
        b = *it ;
    }
    if ( CalcDeep(a.second) < CalcDeep(b.second) ) swap( a , b ) ;
    Link( a , make_pair( x , Cnt ) ) ;
    ans = CalcDeep( Cnt ) ;
    PAIR ins = make_pair( x , Cnt ) ;
    Q.insert( ins ) ;
}

void RotateMin( int op ) {
    set < PAIR > :: iterator it = Q.begin() ;
    int x = (*it).second ;
    if ( x == Root ) {
        ans = 1 ;
        if ( op == 4 ) {
            if ( TSon[x][0] ) Root = TSon[x][0] ;
            else if ( TSon[x][1] ) Root = TSon[x][1] ;
            else Root = 0 ;
            if ( Root ) Cut( *it , make_pair( key[Root] , Root ) ) ;
            Q.erase(it) ;
        }
        return ;
    }
    ans = CalcDeep(x) ;
    int son = TSon[x][1] , f = fa[x] ;
    if ( son ) Cut( *it , make_pair( key[son] , son ) ) ;
    if ( f ) Cut( make_pair( key[f] , f ) , *it ) ;
    MakeRoot( Root ) ;
    if ( f && son ) Link( make_pair( key[f] , f ) , make_pair( key[son] , son ) ) ;
    if ( op == 4 ) {
        Pre[Root] = 0 ;
        Q.erase(it) ;
    } else {
        if ( Root ) Link( *it , make_pair( key[Root] , Root ) ) ;
        Root = x ;
    }
}

void RotateMax( int op ) {
    set < PAIR > :: iterator it = Q.end() ;
    it -- ;
    int x = (*it).second ;
    if ( x == Root ) {
        ans = 1 ;
        if ( op == 5 ) {
            if ( TSon[x][0] ) Root = TSon[x][0] ;
            else if ( TSon[x][1] ) Root = TSon[x][1] ;
            else Root = 0 ;
            if ( Root ) Cut( *it , make_pair( key[Root] , Root ) ) ;
            Q.erase(it) ;
        }
        return ;
    }
    ans = CalcDeep(x) ;
    int son = TSon[x][0] , f = fa[x] ;
    if ( son ) Cut( *it , make_pair( key[son] , son ) ) ;
    if ( f ) Cut( make_pair( key[f] , f ) , *it ) ;
    MakeRoot( Root ) ;
    if ( f && son ) Link( make_pair( key[f] , f ) , make_pair( key[son] , son ) ) ;
    if ( op == 5 ) {
        Pre[Root] = 0 ;
        Q.erase(it) ;
    } else {
        if ( Root ) Link( *it , make_pair( key[Root] , Root ) ) ;
        Root = x ;
    }
}

int main() {
    freopen( "splay.in" , "r" , stdin ) ;
    freopen( "splay.out" , "w" , stdout ) ;
    scanf( "%d" , &m ) ;
    for (int i = 1 ; i <= m ; i ++ ) {
        int op ;
        scanf( "%d" , &op ) ;
        ans = 0 ;
        if ( op == 1 ) {
            int x ;
            scanf( "%d" , &x ) ;
            Insert( x ) ;
        }
        if ( op == 2 || op == 4 ) RotateMin( op ) ;
        if ( op == 3 || op == 5 ) RotateMax( op ) ;
        printf( "%d\n" , ans ) ;
    }
    return 0 ;
}

以上.