[Bzoj3223][Tyvj1729] 文艺平衡树(splay/无旋Treap)

题目链接：https://www.lydsy.com/JudgeOnline/problem.php?id=3223

平衡树处理区间问题的入门题目，普通平衡树那道题在维护平衡树上是以每个数的值作为维护的标准，而处理区间问题时，维护平衡树的应该是每个位置的下标，所以平衡树中序遍历时应该是当前区间的样子。例如：

{1 2 3 4 5}翻转区间1 3，则中序遍历应该输出{3,2,1,4,5}。

提供splay和无旋Treap的题解。

splay做法:

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int inf = 2e9;
 const int maxn = ;
 int ch[maxn][], siz[maxn], lazy[maxn], fa[maxn], val[maxn];
 int a[maxn];
 int root, cnt;
 void pushup(int x) {
     siz[x] = siz[ch[x][]] + siz[ch[x][]] + ;
 }
 void pushdown(int x) {
     if (lazy[x]) {
         if (ch[x][])lazy[ch[x][]] ^= ;
         if (ch[x][])lazy[ch[x][]] ^= ;
         swap(ch[x][], ch[x][]);
         lazy[x] = ;
     }
 }
 void rotate(int x) {//将x旋转到x的父亲的位置
     int y = fa[x];
     int z = fa[y];
     pushdown(y); pushdown(x);
     int k = (ch[y][] == x);
     ch[z][ch[z][] == y] = x;
     fa[x] = z;
     ch[y][k] = ch[x][k ^ ];
     fa[ch[x][k ^ ]] = y;
     ch[x][k ^ ] = y;
     fa[y] = x;
     pushup(y); pushup(x);
 }
 void splay(int x, int goal) {//将x旋转为goal的子节点
     while (fa[x] != goal) {
         int y = fa[x];
         int z = fa[y];
         if (z != goal)
             (ch[y][] == x) ^ (ch[z][] == y) ? rotate(x) : rotate(y);
         //如果x和y同为左儿子或者右儿子先旋转y
         //如果x和y不同为左儿子或者右儿子先旋转x
         rotate(x);
     }
     if (goal == )
         root = x;
 }
 int build(int l, int r, int f) {
     if (l > r)return ;
     int mid = l + r >> , now = ++cnt;
     val[now] = a[mid], fa[now] = f, lazy[now] = ;
     ch[now][] = build(l, mid - , now);
     ch[now][] = build(mid + , r, now);
     pushup(now);
     return now;
 }
 int FindK(int root, int k) {
     int now = root;
     while () {
         pushdown(now);
         if (k <= siz[ch[now][]])
             now = ch[now][];
         else {
             k -= siz[ch[now][]] + ;
             if (k == )return now;
             else now = ch[now][];
         }
     }
 }
 void rever(int l, int r) {
     int ll = FindK(root, l);
     int rr = FindK(root, r + );
     splay(ll, );
     splay(rr, ll);
     pushdown(root);
     lazy[ch[ch[root][]][]] ^= ;
 }
 void dfs(int x) {
     pushdown(x);
     if (ch[x][])dfs(ch[x][]);
     if (val[x] != inf && val[x] != -inf)
         printf("%d ", val[x]);
     if (ch[x][])dfs(ch[x][]);
 }
 int main() {
     int n, m;
     scanf("%d%d", &n, &m);
     for (int i = ; i <= n; i++)
         a[i + ] = i;
     a[] = -inf, a[n + ] = inf;
     root = build(, n + , );
     while (m--) {
         int l, r;
         scanf("%d%d", &l, &r);
         rever(l, r);
     }
     dfs(root);
 }

无旋treap做法

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int maxn = 1e5 + ;
 int Siz[maxn], ls[maxn], rs[maxn], pos[maxn], lazy[maxn], root;
 int cnt;
 inline void up(int x) {
     Siz[x] = Siz[ls[x]] + Siz[rs[x]] + ;
 }
 inline void down(int x) {
     if (lazy[x]) {
         swap(ls[x], rs[x]);
         lazy[ls[x]] ^= ;
         lazy[rs[x]] ^= ;
         lazy[x] = ;
     }
 }
 void split_size(int x, int siz, int &A, int &B) {
     if (x == )return (void)(A = B = );
     down(x);
     if (siz <= Siz[ls[x]])
         B = x, split_size(ls[x], siz, A, ls[x]);
     else
         A = x, split_size(rs[x], siz - Siz[ls[x]] - , rs[x], B);
     up(x);
 }
 int Merge(int A, int B) {
     if (A ==  || B == )return A | B;
     int ans;
     down(A);
     down(B);
     if (pos[A] > pos[B])ans = A, rs[A] = Merge(rs[A], B);
     else ans = B, ls[B] = Merge(A, ls[B]);
     up(ans);
     return ans;
 }
 int build(int l, int r) {
     if (l > r)return ;
     int mid = l + r >> ;
     ls[mid] = build(l, mid - );
     rs[mid] = build(mid + , r);
     pos[mid] = rand();
     up(mid);
     return mid;
 }
 void dfs(int x) {
     if (x) {
         down(x);
         dfs(ls[x]);
         printf("%d ", x);
         dfs(rs[x]);
     }
 }
 int main() {
     int n, m;
     scanf("%d%d", &n, &m);
     root = build(, n);
     while (m--) {
         int l, r;
         scanf("%d%d", &l, &r);
         int A, B, C, D;
         split_size(root, l - , A, B);
         split_size(B, r - l + , C, D);
         lazy[C] ^= ;
         root = Merge(A, Merge(C, D));
     }
     dfs(root);
     system("pause");
     return ;
 }