「刷题记录」P1110 [ZJOI2007] 报表统计

题目描述#

小 $Q$ 的妈妈是一个出纳，经常需要做一些统计报表的工作。今天是妈妈的生日，小 $Q$ 希望可以帮妈妈分担一些工作，作为她的生日礼物之一。
经过仔细观察，小 $Q$ 发现统计一张报表实际上是维护一个非负整数数列，并且进行一些查询操作。
在最开始的时候，有一个长度为 $n$ 的整数序列 $a$，并且有以下三种操作：

• $\text{INSERT i k}$：在原数列的第 $i$ 个元素后面添加一个新元素 $k$；如果原数列的第 $i$ 个元素已经添加了若干元素，则添加在这些元素的最后（见样例说明）。
• $\text{MIN_GAP}$：查询相邻两个元素的之间差值（绝对值）的最小值。
• $\text{MIN_SORT_GAP}$：查询所有元素中最接近的两个元素的差值（绝对值）。
  于是小 $Q$ 写了一个程序，使得程序可以自动完成这些操作，但是他发现对于一些大的报表他的程序运行得很慢，你能帮助他改进程序么？

输入格式#

第一行包含两个整数，分别表示原数列的长度 $n$ 以及操作的次数 $m$。
第二行为 $n$ 个整数，为初始序列，第 $i$ 个整数表示 $a_i$。
接下来的 $m$ 行，每行一个操作，即 $INSERT\ i\ k$，$MIN\_GAP$，$MIN\_SORT\_GAP$ 中的一种（无多余空格或者空行）。

输出格式#

对于每一个 $MIN\_GAP$ 和 $MIN\_SORT\_GAP$ 命令，输出一行答案即可。

样例 #1#

样例输入 #1#

3 5
5 3 1
INSERT 2 9
MIN_SORT_GAP
INSERT 2 6
MIN_GAP
MIN_SORT_GAP

样例输出 #1#

2
2
1

提示#

样例输入输出 1 解释

一开始的序列为 $\{5,3,1\}$。
执行操作 $\text{INSERT 2 9}$ 将得到 $\{5,3,9,1\}$，此时 $\text{MIN_GAP}$ 为 $2$，$\text{MIN_SORT_GAP}$ 为 $2$。
再执行操作 $\text{INSERT 2 6}$ 将得到：$\{5,3, 9, 6, 1\}$。
注意这个时候原序列的第 $2$ 个元素后面已经添加了一个 $9$，此时添加的 $6$ 应加在 $9$ 的后面。这个时候 $\text{MIN_GAP}$ 为 $2$，$\text{MIN_SORT_GAP}$ 为 $1$。

---

数据规模与约定

对于全部的测试点，保证 $2 \le n, m \le 5\times10^5$，$1 \leq i \leq n$，$0 \leq a_i, k \leq 5 \times 10^8$。

---

题意大致就是维护一个序列，可以插入，维护相邻的两个元素的差值和权值相邻的两个元素的差值（即排序后相邻两个元素的差值）
这里维护相邻两个元素的差值可以用可删除堆，即用两个堆模拟，当然，也可以用平衡树来维护，至于权值相邻的两个元素的差值，我们用平衡树维护
这里平衡树我用的 Splay，也可以用 treap，这里不写了，也可以用 STL 的 multset
具体看代码吧：

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstring>
#define ls(p) ch[p][0]
#define rs(p) ch[p][1]
typedef long long ll;
using namespace std;
const int N = 5e6 + 5;
const ll INF = 1e9 + 5;
const ll inf = -1e9 + 5;
int n, m;
ll minn = INF;
ll sz[N][2];// 插入数的头和尾
char op[20];// 操作

struct Splay_tree {// 封装的splay平衡树
	int root = 0, tot;
	int ch[N][2], fa[N];
	ll val[N], siz[N], cnt[N];
	
	void pushup(int cur) {// 更新
		siz[cur] = siz[ls(cur)] + siz[rs(cur)] + cnt[cur];
	}
	
	void spin(int x) {// 旋转
		int y = fa[x], z = fa[y], d = (ch[y][1] == x);
		ch[z][ch[z][1] == y] = x, fa[x] = z;
		ch[y][d] = ch[x][d ^ 1], fa[ch[x][d ^ 1]] = y;
		ch[x][d ^ 1] = y, fa[y] = x;
		pushup(y), pushup(x);
	}
	
	void splay(int x, int goal) {// splay
		while(fa[x] != goal) {
			int y = fa[x], z = fa[y];
			if(z != goal) {
				(ch[y][0] == x) ^ (ch[z][0] == y) ? spin(x) : spin(y);
			}
			spin(x);
		}
		if(!goal)	root = x;	
	}
	
	void insert(ll x) {// 插入
		int u = root, fat = 0;
		while(u && val[u] != x) {
			fat = u;
			u = ch[u][x > val[u]];
		}
		if(u)	cnt[u]++;
		else {
			u = ++tot;
			if(fat)	ch[fat][x > val[fat]] = u;
			fa[u] = fat;
			val[u] = x;
			siz[u] = 1;
			cnt[u] = 1;
		}
		splay(u, 0);
	}
	
	void found(ll x) {// 查找
		int u = root;
		if(!u)	return ;
		while(ch[u][x > val[u]] && x != val[u]) {
			u = ch[u][x > val[u]];
		}
		splay(u, 0);
	}
	
	ll get(ll x, int d) {// 找前驱后继 d: 0 前驱 1 后继
		found(x);
		int u = root;
		if(val[u] == x && cnt[u] >= 1)	return val[u];
		//这里为什么是大于等于1呢
		//因为在这个题中,找前驱后继的元素是将要插入到序列中的元素
		if((val[u] > x && d) || (val[u] < x && !d))	return val[u];
		u = ch[u][d];
		while(ch[u][d ^ 1]) {
			u = ch[u][d ^ 1];
		}
		return val[u];
		//一定要记录值！返回位置的话,一定要在进行其他操作之前记录下权值
		//因为位置是会随着旋转而更新的
	}
	
} splay;

struct Heap {// 可删除堆
	priority_queue<ll, vector<ll>, greater<ll> > q1, q2;// q1 插入的元素 q2 要删除的元素
	
	void insert(ll x) {// 插入
		q1.push(x);
	}
	
	void del(ll x) {// 删除
		q2.push(x);
	}
	
	ll get() {// 取堆顶
		while(!q2.empty() && !q1.empty() && q2.top() == q1.top()) {
			q1.pop(), q2.pop();
		}
		return q1.top();
	}
} heap;

inline ll read() {
	ll x = 0;
	int fg = 0;
	char ch = getchar();
	while(ch < '0' || ch > '9') {
		fg |= (ch == '-');
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9') {
		x = (x << 3) + (x << 1) + (ch ^ 48);
		ch = getchar();
	}
	return fg ? ~x + 1 : x;
}

int main() {
	n = read(), m = read();
	memset(sz, -1, sizeof sz);
	splay.insert(INF);
	splay.insert(inf);
	for(int i = 1; i <= n; ++i) {
		sz[i][0] = read();
		if(i != 1) {
			heap.insert(abs(sz[i][0] - sz[i - 1][0]));
		}
		if(minn) {
			ll ql = splay.get(sz[i][0], 0);
			ll qr = splay.get(sz[i][0], 1);
			if(ql == sz[i][0] || qr == sz[i][1]) {
				minn = 0;
				continue;
			}
			if(qr != INF) {
				minn = min(minn, abs(qr - sz[i][0]));
			}
			if(ql != inf) {
				minn = min(minn, abs(ql - sz[i][0]));
			}
			splay.insert(sz[i][0]);
		}
	}
	while(m--) {
		scanf("%s", op);
		if(op[4] == 'S') {
			printf("%lld\n", minn);
		}
		if(op[4] == 'G') {
			printf("%lld\n", heap.get());
		}
		if(op[4] == 'R') {
			int pos = read();
			ll val = read();
			if(sz[pos][1] == -1) {
				heap.insert(abs(sz[pos][0] - val));
			}
			else {
				heap.insert(abs(sz[pos][1] - val));
			}
			if(pos != n) {
				heap.insert(abs(sz[pos + 1][0] - val));
				heap.del(abs(sz[pos + 1][0] - sz[pos][sz[pos][1] != -1]));
			}
			sz[pos][1] = val;
			if(minn) {
				ll ql = splay.get(val, 0);
				ll qr = splay.get(val, 1);
				if(ql == val || val == qr) {
					minn = 0;
					continue;
				}
				if(qr != INF) {
					minn = min(minn, abs(qr - val));
				}
				if(ql != inf) {
					minn = min(minn, abs(ql - val));
				}
				splay.insert(val);
			}
		}
	}
	return 0;
}