洛谷P3377 左偏树的并堆写法（启发式合并）

题目描述

如题，一开始有 nn 个小根堆，每个堆包含且仅包含一个数。接下来需要支持两种操作：

1. 1 x y：将第 xx 个数和第 yy 个数所在的小根堆合并（若第 xx 或第 yy 个数已经被删除或第 xx 和第 yy 个数在用一个堆内，则无视此操作）。

2. 2 x：输出第 xx 个数所在的堆最小数，并将这个最小数删除（若有多个最小数，优先删除先输入的；若第 xx 个数已经被删除，则输出 -1−1 并无视删除操作）。

输入格式

第一行包含两个正整数 n, mn,m，分别表示一开始小根堆的个数和接下来操作的个数。

第二行包含 nn 个正整数，其中第 ii 个正整数表示第 ii 个小根堆初始时包含且仅包含的数。

接下来 mm 行每行 22 个或 33 个正整数，表示一条操作，格式如下：

操作 11：1 x y

操作 22：2 x

输出格式

输出包含若干行整数，分别依次对应每一个操作 22 所得的结果。

输入输出样例

输入 #1复制

5 5
1 5 4 2 3
1 1 5
1 2 5
2 2
1 4 2
2 2

输出 #1复制

1
2

说明/提示

【数据规模】

对于 30\%30% 的数据：n\le 10n≤10，m\le 10m≤10。
对于 70\%70% 的数据：n\le 10^3n≤103，m\le 10^3m≤103。
对于 100\%100% 的数据：n\le 10^5n≤105，m\le 10^5m≤105，初始时小根堆中的所有数都在 int 范围内。

【样例解释】

初始状态下，五个小根堆分别为：\{1\}{1}、\{5\}{5}、\{4\}{4}、\{2\}{2}、\{3\}{3}。

第一次操作，将第 11 个数所在的小根堆与第 55 个数所在的小根堆合并，故变为四个小根堆：\{1,3\}{1,3}、\{5\}{5}、\{4\}{4}、\{2\}{2}。

第二次操作，将第 22 个数所在的小根堆与第 55 个数所在的小根堆合并，故变为三个小根堆：\{1,3,5\}{1,3,5}、\{4\}{4}、\{2\}{2}。

第三次操作，将第 22 个数所在的小根堆的最小值输出并删除，故输出 11，第一个数被删除，三个小根堆为：\{3,5\}{3,5}、\{4\}{4}、\{2\}{2}。

第四次操作，将第 44 个数所在的小根堆与第 22 个数所在的小根堆合并，故变为两个小根堆：\{2,3,5\}{2,3,5}、\{4\}{4}。

第五次操作，将第 22 个数所在的小根堆的最小值输出并删除，故输出 22，第四个数被删除，两个小根堆为：\{3,5\}{3,5}、\{4\}{4}。

故输出依次为 11、22。

解法：

对set重载，按照题目要求的顺序进行排序，即先大小，后下标，再用并查集维护

Accepted code

#include<bits/stdc++.h>
#include<unordered_map>
using namespace std;

#define sc scanf
#define ls rt << 1
#define rs ls | 1
#define Min(x, y) x = min(x, y)
#define Max(x, y) x = max(x, y)
#define ALL(x) (x).begin(),(x).end()
#define SZ(x) ((int)(x).size())
#define pir pair <int, int>
#define MK(x, y) make_pair(x, y)
#define MEM(x, b) memset(x, b, sizeof(x))
#define MPY(x, b) memcpy(x, b, sizeof(x))
#define lowbit(x) ((x) & -(x))
#define P2(x) ((x) * (x))

typedef long long ll;
const int MOD = 1e9 + 7;
const int N = 1e5 + 100;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
inline ll dpow(ll a, ll b){ ll r = 1, t = a; while (b){ if (b & 1)r = (r*t) % MOD; b >>= 1; t = (t*t) % MOD; }return r; }
inline ll fpow(ll a, ll b){ ll r = 1, t = a; while (b){ if (b & 1)r = (r*t); b >>= 1; t = (t*t); }return r; }

struct node
{
	int id, x;
	bool operator < (const node &oth) const {
		if (x == oth.x)
			return id < oth.id;       
		else
			return x < oth.x;
	}
};
int f[N], sz[N];
bool vis[N];
multiset <node> st[N];

int find_(int x) {
	while (x != f[x])
		x = f[x];
	return x;
}
void unite(int x, int y) {
	x = find_(x);
	y = find_(y);
	if (x == y)
		return;
	if (sz[x] > sz[y])
		swap(x, y);
	f[x] = y;
	sz[y] += sz[x];
	for (auto it : st[x])  // 小的合并到大的里面
		st[y].insert(it);
	st[x].clear();
}

int main()
{
	int n, q;
	cin >> n >> q;
	for (int i = 1; i <= n; i++) {
		int t;
		sc("%d", &t);
		f[i] = i, sz[i] = 1;
		st[i].insert({ i, t }); 
	}
	while (q--) {
		int op, x, y;
		sc("%d", &op);
		if (op & 1) {
			sc("%d %d", &x, &y);
			if (vis[x] || vis[y])  // 已经删除
				continue;
			unite(x, y);
		}
		else {
			sc("%d", &x);
			if (vis[x])
				printf("-1\n");
			else {
				x = find_(x);
				printf("%d\n", st[x].begin()->x);
				int idx = st[x].begin()->id;
				vis[idx] = true;                // 标记删除
				st[x].erase(st[x].begin());
			}
		}
	}
	return 0;  // 改数组大小!!!用pair记得改宏定义!!!
}