首页 > 其他分享> > P1110 [ZJOI2007] 报表统计

P1110 [ZJOI2007] 报表统计

2022-08-08 10:04:25 作者：互联网

[ZJOI2007] 报表统计

题目描述

小 Q 的妈妈是一个出纳，经常需要做一些统计报表的工作。今天是妈妈的生日，小 Q 希望可以帮妈妈分担一些工作，作为她的生日礼物之一。

经过仔细观察，小 Q 发现统计一张报表实际上是维护一个非负整数数列，并且进行一些查询操作。

在最开始的时候，有一个长度为 \(n\) 的整数序列 \(a\)，并且有以下三种操作：

INSERT i k：在原数列的第 \(i\) 个元素后面添加一个新元素 \(k\)；如果原数列的第 \(i\) 个元素已经添加了若干元素，则添加在这些元素的最后（见样例说明）。
MIN_GAP：查询相邻两个元素的之间差值（绝对值）的最小值。
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\}\)。

执行操作 INSERT 2 9 将得到 \(\{5,3,9,1\}\)，此时 MIN_GAP 为 \(2\)，MIN_SORT_GAP 为 \(2\)。

再执行操作 INSERT 2 6 将得到：\(\{5,3, 9, 6, 1\}\)。

注意这个时候原序列的第 \(2\) 个元素后面已经添加了一个 \(9\)，此时添加的 \(6\) 应加在 \(9\) 的后面。这个时候 MIN_GAP 为 \(2\)，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;
}

标签：P1110,ch,报表,val,MIN,int,ll,GAP,ZJOI2007
来源： https://www.cnblogs.com/yifan0305/p/16560746.html