Bzoj P3223 [Tyvj1729]文艺平衡树___splay

题目大意：

维护一个长度为$n$的有序数列，其中需要提供以下操作：翻转一个区间。
初始时这个序列依次是$(1,2\dots \dots n-1,n)$ ，操作数有$m$个。

$n,m<=100000$

分析：

splay的一个基本操作就是区间反转，
首先将$[1,n]$类似线段树一样建出一颗二叉搜索树，然后将$splay$要用到的东西都处理好
对于每次我们要反转的区间$[l,r]$，
我们只需要找到第$l-1$个数(区间左往右数第$l-1$个)的结点，将它旋转到根，
再找到第$r+1$个数，将它旋转到根的右儿子，
那么此时我们可以发现，因为始终是满足二叉搜索树的性质的，
则根的右儿子的左儿子的整个子树，就包含了$[l,r]$的所有结点，且中序遍历就是区间$[l,r]$
那么我们这时候还要进行的操作就是将这颗子树各个结点的左右儿子对调，
对于这个操作我们可以打个$lazy$标记，
然后每次做到某个点的时候就看一下这个点为根的子树是否被标记过，
标记过就交换其左右儿子，然后下传标记
为了避免越界，我们一开始左右多开一个点，其结点数值分别是±无穷大

代码：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <queue>
#include <cstdlib>
#include <algorithm>


#define rep(i, st, ed) for (int i = st; i <= ed; i++)
#define rwp(i, ed, st) for (int i = ed; i >= st; i--)

#define inf 0x7fffffff
#define N 1000005

using namespace std;

int son[N][2], size[N], lzy[N], num[N], cnt[N], key[N], f[N];
int root, tot, n, m;

bool get(int x)
{
	return son[f[x]][1] == x;
}

void update(int x)
{
	if (x) { size[x] = cnt[x] + (son[x][0] ? size[son[x][0]] : 0) + (son[x][1] ? size[son[x][1]] : 0); }
}

void pushdown(int x)
{
   if (x && lzy[x]) { lzy[x] = 0, lzy[son[x][0]] ^= 1, lzy[son[x][1]] ^= 1, swap(son[x][0], son[x][1]); }	
}

void rotate(int x)
{
	int fa = f[x], fafa = f[fa], num = get(x);
	pushdown(fa); pushdown(x); 
	son[fa][num] = son[x][num^1]; f[son[fa][num]] = fa;
	son[x][num^1] = fa; f[fa] = x; f[x] = fafa;
	if (fafa) son[fafa][son[fafa][1] == fa] = x;
	update(fa); update(x);
}

void splay(int x, int y)
{
    int fa = f[x];
	for (; fa != y; fa = f[x])
	{
	    if (f[fa] != y) rotate((get(x) == get(fa) ? fa : x));
        rotate(x); 
	}
	if (!y) root = x;

}

int Build(int l, int r, int fa) 
{
    if (l > r) { return 0; }
    int mid = (l + r) >> 1;
    int now = ++tot;
    f[now] = fa;
    cnt[now] = 1; key[now] = num[mid];
    son[now][0] = Build(l, mid - 1, now);
    son[now][1] = Build(mid + 1, r, now);
    update(now);    
    return now;
}

int Get_RanknumID(int x)
{
	int now = root;
	while (now)
	{
		pushdown(now);
		int cdp = (son[now][0] ? size[son[now][0]] : 0);
		if (x <= cdp) now = son[now][0];
		else
		{
			if (x <= cdp + cnt[now]) return now;
			x -= (cdp + cnt[now]); 
			now = son[now][1];
		}
	}
	return 0;
}


void Work(int x, int y)
{ 
    int l = Get_RanknumID(x - 1);
	int r = Get_RanknumID(y + 1);
    splay(l, 0);
    splay(r, l);   
    lzy[son[r][0]] ^= 1; 
}

void dfs(int x)
{
	pushdown(x);
	if (son[x][0]) dfs(son[x][0]);
	if (key[x] != inf && key[x] != -inf) printf("%d ", key[x]);
	if (son[x][1]) dfs(son[x][1]); 
}

int main()
{
	scanf("%d %d", &n, &m);
	rep(i, 1, n) num[i + 1] = i; 
	num[1] = -inf; num[n + 2] = inf; 
	root = Build(1, n + 2, 0);
	int l, r;
	rep(i, 1, m) scanf("%d %d", &l, &r), Work(l + 1, r + 1);
	dfs(root);
    return 0;
}