Treap模板（支持Merge/Split）

#include 
   
   
    
    
using namespace std;

#define maxn 2000005
#define rep(i, x, y) for(int i = x;i <= y; ++i)
#define dep(i, x, y) for(int i = x;i >= y; --i)

int ran() {
	static int x = 1364684679;
	x += (x << 2) + 1;
	return x;
}

struct Treap
{
	Treap *l, *r;
	int fix, key, size;
	Treap(int key_) :fix(ran()), key(key_), l(NULL), r(NULL), size(1) {}

	inline void update() { size = 1 + (l ? l->size : 0) + (r ? r->size : 0); }
}*root;

typedef pair
    
    
     
      Droot;   //split() return two roots

inline int size(Treap *x) { return x ? x->size : 0; }    //avoid x == NULL

Treap* merge(Treap *a, Treap *b)
{
	if (!a) return b;
	if (!b) return a;
	if (a->fix < b->fix)
	{
		b->l = merge(a, b->l);
		b->update();
		return b;
	}
	else
	{
		a->r = merge(a->r, b);
		a->update();
		return a;
	}
}

Droot split(Treap *x, int k)
{
	if (!x) return Droot(NULL, NULL);
	Droot y;
	if (size(x->l) >= k)
	{
		y = split(x->l, k);
		x->l = y.second;
		x->update();
		y.second = x;
	}
	else
	{
		y = split(x->r, k - size(x->l) - 1);
		x->r = y.first;
		x->update();
		y.first = x;
	}
	return y;
}

Treap *build(int *a)
{
	static Treap *stack[maxn], *x, *last;
	int p = 0;
	rep(i, 1, a[0])
	{
		x = new Treap(a[i]);
		last = NULL;
		while (p && stack[p]->fix > x->fix)
		{
			stack[p]->update();
			last = stack[p];
			stack[p--] = NULL;
		}
		if (p) stack[p]->r = x;
		x->l = last;
		stack[++p] = x;
	}
	while (p) stack[p--]->update();
	return stack[1];
}

int findKth(int k)
{
	Droot x = split(root, k - 1);
	Droot y = split(x.second, 1);
	Treap *ans = y.first;
	root = merge(merge(x.first, ans), y.second);
	return ans->key;
}

int getIdx(Treap *x, int v)
{
	if (!x) return 0;
	return v < x->key ? getIdx(x->l, v) : getIdx(x->r, v) + size(x->l) + 1;
}

void insert(int v)   // insert v
{
	int k = getIdx(root, v);
	Droot x = split(root, k);
	Treap *n = new Treap(v);
	root = merge(merge(x.first, n), x.second);
}

void delete_(int k)    // delete kth element
{
	Droot x = split(root, k - 1);
	Droot y = split(x.second, 1);
	root = merge(x.first, y.second);
}