BZOJ-3595 方伯伯的OJ 双Treap

大家都很强， 可与之共勉。

/**************************************************************
Problem: 3595
User: Lazer2001
Language: C++
Result: Accepted
Time:2252 ms
Memory:16952 kb
****************************************************************/

#include <cctype>
#include <cstdio>

namespace FastIO  {
const size_t str = 1 << 20;

struct Reader  {
char buf[str], *s, *t;
Reader ( ) : s( ), t( ), buf() {    }
inline char pick ( )  {
return (s == t) ? ( t = buf + fread ( s = buf, 1, str , stdin ), *s++ ) : ( *s++ );
}

template < class T >
inline Reader& operator >> ( T& x )  {
static char ch;
static short opt;
opt = (ch != 45);
while ( !isdigit ( ch = pick () ) && (ch ^ -1) && ( ch ^ 45 ) );
if ( ch == -1 )     return *this;
if ( ch == 45 )     {   opt = 0; ch = pick ();   }
for ( x = -48 + ch; isdigit ( ch = pick () ); ( x *= 10 ) += ch - 48 );
opt ? 1 : x = -x;
return *this;
}

} cin;

struct Writer  {
char buf[str], *s, *t;
Writer () : s ( buf ), t( buf + str ), buf ( ) {    }
~Writer () { fwrite( buf, 1, s - buf, stdout ); }

inline void echo ( char c )  {
( s == t ) ? ( fwrite ( s = buf, 1, str, stdout ), *s++ = c ) : ( *s++ = c );
}

inline Writer& operator << ( long long x )  {
if( !x ) return echo( 48 ), *this;
static int t[21], top;
while ( x ) t[++top] = x % 10, x /= 10;
while ( top ) echo(t[top--] + 48);
return *this;
}
inline Writer& operator << (const char* s)  {
while ( *s ) echo( *s++ ) ;
return *this;
}
} cout;
const char *endl = "\n";
}

using FastIO :: cin;
using FastIO :: cout;
using FastIO :: endl;

inline int rand ( )  {
static int seed = 233;
return seed = ( int ) seed * 482711LL % 2147483647;
}

const int Inf = 0x3f3f3f3f;

int cnt = 1, tot = 1;

class Treap{
public:
struct node{
node *lc, *rc;
int s, id, r, L, R;
}t[300055], *null, *root;

inline void init()  {
null = &t[0]; null -> lc = null -> rc = null;
null -> s = 0; null -> id = null -> L = null -> R = null -> r = -Inf;
root = null;
}

inline node *NewNode(int index, int L, int R)  {
t[cnt].lc = t[cnt].rc = null; t[cnt].r = rand();
t[cnt].id = index; t[cnt].L = L; t[cnt].R = R; t[cnt].s = R - L + 1;
return &t[cnt++];
}

inline void pushup(node *&p){ p->s = p->lc->s + p->rc->s + (p->R-p->L+1);}

inline void maintain(node *&p)  {
if(p->lc->r > p->r)  {
node *temp = p -> lc;
p -> lc = temp -> rc;
temp -> rc = p;
pushup(p); p = temp;
}
else if(p->rc->r > p->r)  {
node *temp = p -> rc;
p -> rc = temp -> lc;
temp -> lc = p;
pushup(p); p = temp;
}
pushup(p);
}

inline void insert(node *&p, int L, int R, int index)  {
if(p == null)  {
p = NewNode(index, L, R);
return;
}
if(R < p -> L) insert(p -> lc, L, R, index);
else insert(p -> rc, L, R, index);
maintain(p);
}

inline void merge(node *&ne, node *p, node *q)  {
if(p == null || q == null)  {
ne = p == null ? q : p;
return;
}
if(p->r > q->r) { ne = p; merge(ne->rc, p->rc, q); }
else{ ne = q; merge(ne->lc, p, q->lc); }
pushup(ne);
}

inline void del(node *&p, int pos)  {
if(p == null) return;
if(p->L <= pos && pos <= p->R)  {
if(p->L == p->R) merge(p, p->lc, p->rc);
else if(p->L == pos) { ++ p -> L; ++ p -> id; pushup(p); }
else if(p->R == pos) { -- p -> R; pushup(p); }
else  {
insert(p -> rc, pos + 1, p -> R, pos + 1);
p -> R = pos - 1; pushup(p);
}
return;
}
if(p->L > pos) del(p -> lc, pos);
else del(p -> rc, pos); maintain(p);
}

inline int getrank(node *&p, int pos)  {
if(p == null) return 0;
if(p->L <= pos && pos <= p->R) return (pos - p->L + 1) + p->lc->s;
if(p->L > pos) return getrank(p->lc, pos);
else return getrank(p->rc, pos) + p->lc->s + (p->R - p->L + 1);
}

inline int getindex(node *&p, int k)  {
if(p == null) return 0;
int lsize = p->lc->s;
if(k <= lsize) return getindex(p->lc, k);
if(lsize < k && lsize + (p->R - p->L + 1) >= k)  {
if(p->L == p->R) return p->id;
else return k-lsize-1 + p->L;
}
else return getindex(p->rc, k - lsize - (p->R - p->L + 1));
}
}t;

struct Map  {
struct node  {
node *lc, *rc;
int r, id, rank;
}t[300055], *null, *root;

inline void init()  {
null = &t[0]; null -> lc = null -> rc = null;
null -> rank = null -> r = -Inf; root = null;
}

inline node *NewNode(int index, int rank)  {
t[tot].lc = t[tot].rc = null; t[tot].r = rand();
t[tot].id = index; t[tot].rank = rank; return &t[tot++];
}

inline void maintain(node *&p)  {
if(p->lc->r > p->r)  {
node *temp = p -> lc;
p -> lc = temp -> rc;
temp -> rc = p; p = temp;
}
else if(p->rc->r > p->r)  {
node *temp = p -> rc;
p -> rc = temp -> lc;
temp -> lc = p; p = temp;
}
}

inline void insert(node *&p, int index, int rank)  {
if(p == null)  {
p = NewNode(index, rank);
return;
}
if(index == p -> id) p -> rank = rank;
else if(index < p -> id) insert(p -> lc, index, rank);
else insert(p -> rc, index, rank);
maintain(p);
}

inline int find(node *&p, int index)  {
if(p == null) return 0;
if(p -> id == index) return p -> rank;
if(p -> id > index) return find(p -> lc, index);
return find(p -> rc, index);
}

inline void remove(node *&p, int index)  {
if(p == null) return;
if(p -> id == index) p -> rank = 0;
else if(p -> id > index) remove(p -> lc, index);
else remove(p -> rc, index);
}
} m;

int main()  {
register int N, M;
t.init(); m.init();
cin >> N; t.insert(t.root, 1, N, 1);
int mmin = 0, mmax = N, a = 0;
for ( cin >> M; M; --M )  {
static int sign, x, pos;
cin >> sign >> x;
x -= a;
if(sign == 1)  {
static int y;
cin >> y;
y -= a;
pos = m.find(m.root, x); if(!pos) pos = x;
a = t.getrank(t.root, pos);
cout << a << endl;
t.del(t.root, pos);
t.insert(t.root, pos, pos, y);
m.remove(m.root, x); m.insert(m.root, y, pos);
}
else if(sign == 2)  {
pos = m.find(m.root, x); if(!pos) pos = x;
a = t.getrank(t.root, pos);
cout << a << endl;
t.del(t.root, pos); m.insert(m.root, x, pos = --mmin);
t.insert(t.root, pos, pos, x);
}
else if(sign == 3)  {
pos = m.find(m.root, x); if(!pos) pos = x;
a = t.getrank(t.root, pos);
cout << a << endl;
t.del(t.root, pos); m.insert(m.root, x, pos = ++mmax);
t.insert(t.root, pos, pos, x);
}
else {
a = t.getindex(t.root, x);
cout << a << endl;
}
}
}