【洛谷】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 {
    
    
    int l, r;
    int key, val;
    int size;
    bool reverse;
} tr[N];

int n, m;
int root, idx;

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

void pushup(int p) {
    
    
    tr[p].size = tr[tr[p].l].size + tr[tr[p].r].size + 1;
}

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

void split(int p, int sz, int &x, int &y) {
    
    
    if (!p) x = y = 0;
    else {
    
    
    	// 要分裂p了，先下传懒标记
        if (tr[p].reverse) pushdown(p);
        if (tr[tr[p].l].size < sz) {
    
    
            x = p;
            split(tr[p].r, sz - tr[tr[p].l].size - 1, tr[p].r, y);
        } else {
    
    
            y = p;
            split(tr[p].l, sz, x, tr[p].l);
        }
		
		// 分裂完之后pushup。注意，这个pushup操作必须写在else里，
		// 否则会pushup 0节点，size会错
        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].reverse) pushdown(x);
        tr[x].r = merge(tr[x].r, y);
        pushup(x);
        // x是新树根
        return x;
    } else {
    
    
        if (tr[y].reverse) pushdown(y);
        tr[y].l = merge(x, tr[y].l);
        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].reverse ^= 1;
    root = merge(merge(x, y), z);
}

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

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);

    return 0;
}

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