【洛谷】P3391 【模板】文艺平衡树

题目地址：

https://www.luogu.com.cn/problem/P3391

题目描述：
您需要写一种数据结构（可参考题目标题），来维护一个有序数列。其中需要提供以下操作：翻转一个区间，例如原有序序列是5 4 3 2 1，翻转区间是$[2,4]$的话，结果是5 2 3 4 1。

输入格式：
第一行两个正整数$n,m$，表示序列长度与操作个数。序列中第$i$项初始为$i$。接下来$m$行，每行两个正整数$l,r$，表示翻转的区间。

输出格式：
输出一行$n$个正整数，表示原始序列经过$m$次变换后的结果。

数据范围：
对于$100\%$的数据，$1\le n,m\le 100000$，$1\le l\le r\le n$。

可以用splay tree或者fhq treap来做。splay的做法可以参考https://blog.csdn.net/qq_46105170/article/details/121119399。下面给出fhq treap的做法。fhq treap的介绍可以参考：https://blog.csdn.net/qq_46105170/article/details/118997891。在本题里，每个Node里除了需要存左右孩子下标，树权和堆权之外，还需要存该子树的节点个数，和一个懒标记reverse。存子树节点个数的目的是快速分裂出$[l,r]$这个区间。可以先将$1,2,...,n$加入fhq treap（加入的方式就是，对于初始树根root，不停合并新节点即可。由于merge是维持BST性质的，所以按顺序merge进去就会得到中序遍历是$1,2,...,n$的树）。翻转$[l,r]$的操作如下：
1、对树根先分裂出$l-1$大小的树，这个树对应着$[1,l-1]$这个区间；
2、对第二棵树分裂出$r-l+1$大小的树，这个树对应着$[l,r]$这个区间；
3、对$[l,r]$这棵树进行翻转，翻转的方式是懒标记直接异或$1$（这样原来是true就变成了false，原来是false就变成了true）；
4、按$[1,l-1],[l,r],[r+1,n]$的顺序合并回来。

尤其需要注意，fhq treap除了有pushup操作之外，还有pushdown操作。如果当前树要分裂的话，必须先下传懒标记，然后再分裂。pushdown的操作是这样的，先交换左右子树，然后将左右子树的懒标记异或$1$。merge的时候也类似，在递归合并之前，需要先pushdown。

代码如下：

#include <iostream>
using namespace std;

const int N = 1e5 + 10;
struct Node {
#define lc(p) tr[p].l
#define rc(p) tr[p].r
#define key(p) tr[p].key
#define sz(p) tr[p].sz
  int l, r;
  int key, val;
  int sz;
  bool rev;
} tr[N];
int n, m;
int root, idx;

int get_node(int key) {
  tr[++idx].key = key;
  tr[idx].val = rand();
  tr[idx].sz = 1;
  return idx;
}

#define pushup(p) sz(p) = sz(lc(p)) + sz(rc(p)) + 1

void pushdown(int p) {
  swap(lc(p), rc(p));
  tr[lc(p)].rev ^= 1;
  tr[rc(p)].rev ^= 1;
  // 懒标记下传完毕，清除当前节点懒标记
  tr[p].rev = false;
}

void split(int p, int sz, int &x, int &y) {
  if (!p)
    x = y = 0;
  else {
    // 要分裂p了，先下传懒标记
    if (tr[p].rev) pushdown(p);
    if (sz(lc(p)) < sz) {
      x = p;
      split(rc(p), sz - sz(lc(p)) - 1, rc(p), y);
    } else {
      y = p;
      split(lc(p), sz, x, lc(p));
    }

    // 分裂完之后pushup。注意，这个pushup操作必须写在else里，
    // 否则会pushup 0节点，sz会错
    pushup(p);
  }
}

// 合并，并维护大顶堆性质
int merge(int x, int y) {
  if (!x || !y) return x ^ y;
  if (tr[x].val > tr[y].val) {
    // 要将x右子树与y合并，合并之前下传x的懒标记
    if (tr[x].rev) pushdown(x);
    rc(x) = merge(rc(x), y);
    pushup(x);
    // x是新树根
    return x;
  } else {
    if (tr[y].rev) pushdown(y);
    lc(y) = merge(x, lc(y));
    pushup(y);
    return y;
  }
}

void reverse(int l, int r) {
  int x, y, z;
  split(root, l - 1, x, y);
  split(y, r - l + 1, y, z);
  tr[y].rev ^= 1;
  root = merge(merge(x, y), z);
}

// 中序遍历打印答案
void dfs(int p) {
  if (!p) return;
  if (tr[p].rev) pushdown(p);
  dfs(lc(p));
  printf("%d ", tr[p].key);
  dfs(rc(p));
}

int main() {
  scanf("%d%d", &n, &m);
  for (int i = 1; i <= n; i++) root = merge(root, get_node(i));

  while (m--) {
    int l, r;
    scanf("%d%d", &l, &r);
    reverse(l, r);
  }

  dfs(root);
}

每次操作时间复杂度$O(\log n)$，空间$O(n)$。