样例没过，0分求调

#include<bits/stdc++.h>
#define INF 0x7f7f7f7f

using namespace std;

struct node
{
	int key;
	int cnt;
	int size;
	int pri;
	node* rightson;
	node* leftson;
}* root;
int n;

void push_up( node* x )
{
	x -> size = x -> rightson -> size + x -> leftson -> size + x -> cnt;
}

void rightrotate( node* &x ) 
{
	node* y = x -> leftson;
	x -> leftson = y -> rightson;
	y -> rightson = x;
	x = y;
	push_up(y);
	push_up(x);
}

void leftrotate( node* &x )
{
	node* y = x -> rightson;
	x -> rightson = y -> leftson;
	y -> leftson = x;
	x = y;
	push_up(y);
	push_up(x);
}

void insert( node* &root, int key, int pri )
{
	if( root == NULL )
	{
		root = (node*)new node;
		root -> leftson = NULL;
		root -> rightson = NULL;
		root -> pri = pri;
		root -> key = key;
		root -> size = 1;
		root -> cnt = 1;
		return;
	}
	else if( key < root -> key )
	{
		insert( root -> leftson, key, pri );
		

		
		if( root -> rightson -> pri < root -> pri )
		{
			leftrotate( root );
		}
	}
	else if( key == root -> key )
	{
		root -> cnt++;
	}
	else
	{
		insert( root -> rightson, key, pri );
		
		if( root -> leftson -> pri < root -> pri )
		{
			rightrotate( root );
		}
		

	}
	
	push_up( root );
}

void remove( node* &root, int key )
{
	if( root != NULL )
	{
		if( key < root -> key )
		{
			remove( root -> leftson, key );
		}
		else if( key > root -> key )
		{
			remove( root -> rightson, key );
		}
		else
		{
			if( root -> cnt > 1 )
			{
				root -> cnt--;
				push_up(root);
				return;
			}
			
			if( root -> leftson == NULL )
			{
				rightrotate(root);
				remove( root -> rightson, key );
			}
			
			if( root -> rightson == NULL )
			{
				leftrotate( root );
				remove( root -> leftson, key  );
			}
			
			if( root -> leftson -> pri < root -> rightson -> pri )
			{
				rightrotate(root);
				remove( root -> rightson, key );
			}
			else
			{
				leftrotate( root );
				remove( root -> leftson, key  );
			}
		}
	}
}

int getrank( node *root, int key )
{
	if( root == NULL )
	{
		return 0;
	}
	
	if( root -> key > key )
	{
		return getrank( root -> leftson, key );
	}
	else if( root -> key < key )
	{
		return root -> leftson -> size + root -> cnt + getrank( root -> rightson, key );
	}
}

int getkey( node* root, int rank )
{
	if( root == NULL )
	{
		return INF;
		
	}
	
	if( root -> leftson -> size >= rank )
	{
		return getkey( root -> leftson, rank );
		
	}
	else if( root -> leftson -> size + root -> cnt < rank )
	{
		return getkey( root -> rightson, rank - root -> leftson -> size - root -> cnt );
		
	}
	else
	{
		return root -> key;
		
	}
}

int getprev( node* root, int key )
{
	if( root == NULL )
	{
		return -INF;
	}
	
	if( root -> key >= key )
	{
		return getprev( root -> leftson, key );
	}
	else
	{
		return max( root -> key, getprev( root -> rightson, key ) );
	}
}

int getnext( node* root, int key )
{
	if( root == NULL )
	{
		return INF;
	}
	
	if( root -> key <= key )
	{
		return getnext( root -> rightson, key );
	}
	else
	{
		return min( root -> key, getnext( root -> leftson, key ) );
	}
}

int main()
{
	//srand( time(0) );
	
	cin >> n;
	
	//build();
	for( int i = 1; i <= n; i++ )
	{
		int x, y;
		
		cin >> x >> y;
		
		if( x == 1 ) insert( root, y, rand() );
		if( x == 2 ) remove( root, y );
		if( x == 3 ) cout << getrank( root, y ) << endl;
		if( x == 4 ) cout << getkey( root, y ) << endl, cout <<222 << endl;;
		if( x == 5 ) cout << getprev( root, y ) << endl;
		if( x == 6 ) cout << getnext( root, y ) << endl;
	}
}