题目地址:
https://www.luogu.com.cn/problem/P3391
题目描述:
您需要写一种数据结构(可参考题目标题),来维护一个有序数列。其中需要提供以下操作:翻转一个区间,例如原有序序列是5 4 3 2 1
,翻转区间是
[
2
,
4
]
[2,4]
[2,4]的话,结果是5 2 3 4 1
。
输入格式:
第一行两个正整数
n
,
m
n,m
n,m,表示序列长度与操作个数。序列中第
i
i
i项初始为
i
i
i。接下来
m
m
m行,每行两个正整数
l
,
r
l,r
l,r,表示翻转的区间。
输出格式:
输出一行
n
n
n个正整数,表示原始序列经过
m
m
m次变换后的结果。
数据范围:
对于
100
%
100\%
100%的数据,
1
≤
n
,
m
≤
100000
1≤n,m≤100000
1≤n,m≤100000,
1
≤
l
≤
r
≤
n
1 \le l \le r \le n
1≤l≤r≤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
]
[l,r]
[l,r]这个区间。可以先将
1
,
2
,
.
.
.
,
n
1,2,...,n
1,2,...,n加入fhq treap(加入的方式就是,对于初始树根root,不停合并新节点即可。由于merge是维持BST性质的,所以按顺序merge进去就会得到中序遍历是
1
,
2
,
.
.
.
,
n
1,2,...,n
1,2,...,n的树)。翻转
[
l
,
r
]
[l,r]
[l,r]的操作如下:
1、对树根先分裂出
l
−
1
l-1
l−1大小的树,这个树对应着
[
1
,
l
−
1
]
[1,l-1]
[1,l−1]这个区间;
2、对第二棵树分裂出
r
−
l
+
1
r-l+1
r−l+1大小的树,这个树对应着
[
l
,
r
]
[l,r]
[l,r]这个区间;
3、对
[
l
,
r
]
[l,r]
[l,r]这棵树进行翻转,翻转的方式是懒标记直接异或
1
1
1(这样原来是true就变成了false,原来是false就变成了true);
4、按
[
1
,
l
−
1
]
,
[
l
,
r
]
,
[
r
+
1
,
n
]
[1,l-1],[l,r],[r+1,n]
[1,l−1],[l,r],[r+1,n]的顺序合并回来。
尤其需要注意,fhq treap除了有pushup操作之外,还有pushdown操作。如果当前树要分裂的话,必须先下传懒标记,然后再分裂。pushdown的操作是这样的,先交换左右子树,然后将左右子树的懒标记异或 1 1 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(\log n) O(logn),空间 O ( n ) O(n) O(n)。