优先队列和重载运算符

1 优先队列

1.1 堆

优先队列的底层实现是堆。

堆一定是一棵完全二叉树。堆分为大根堆和小根堆两种。一个堆，仅有堆顶（根节点）有意义，所以堆只有 放入（up） 和 删除（down） 两种操作，且删除的对象只能是堆顶。

以大根堆举例：

大根堆的特点是，对于每个节点，其儿子节点一定要比父亲节点小。所以，大根堆的堆顶一定是所有元素中最大的一个。

• 放入（up）：由于堆一定要求是完全二叉树，所以把插入的元素放到堆的最后一层从左往右第一个空余的位置上，然后检查此时的大根堆是否满足它的特点（即添加了这个元素后，它的父亲节点是否比它大），如果不满足，把父亲节点和这个元素的值进行交换。重复以上操作，知道该元素到达堆顶或者满足条件为止。
• 删除（down）：删除堆顶，把最后一层从左往右最后一个元素移动到根节点位置上，然后检查此时的大根堆是否满足它的特点（即添加了这个元素后，它的儿子节点是否比它小），如果不满足，选取值较大的儿子节点和这个元素的值进行交换。重复以上操作，知道该元素到达堆底或者满足条件为止。

小根堆同理，与大根堆相反：

小根堆的特点是，对于每个节点，其儿子节点一定要比父亲节点大。所以，大根堆的堆顶一定是所有元素中最小的一个。

• 放入（up）：维护条件父亲节点一定比该元素小，不满足时把父亲节点和这个元素的值进行交换。
• 删除（down）：维护条件该元素一定比儿子节点小，不满足时把值较小的儿子节点和这个元素的值进行交换。

1.2 优先队列 priority_queue

优先队列 priority_queue，即按照优先级自动进行排序的队列，属于STL容器中的一种。优先队列的底层实现就是堆。相同于堆，优先队列也分为两种。

头文件：#include <queue>

操作	含义
priority_queue<int> q	定义一个 int 数据类型的大根堆
priority_queue<int, vector<int>, greater<int> > q	定义一个 int 数据类型的小根堆
q.push(i)	放入元素 i
q.pop()	删除堆顶元素
q.top()	返回堆顶元素的值
q.empty()	判断是否为空，返回 bool 类型
q.size()	返回元素个数

2 重载运算符

2.1 重载运算符

重载运算符，对运算符重新定义、加载，赋予运算符不同的含义的函数语法。通常用于结构体 struct的运算、比较。

举例：

struct node{
	int key, val;
	bool operator<(const node& x) const {   
		//对<进行重载运算符，逻辑运算返回为bool类型，参数为x，另一个参数就是当前这个结构体
		return key < x.key;
	    //对于node类型的变量<定义为 key较小的node < key较大的node
	}
};

2.2 构造函数

对结构体快速赋值的函数语法。

举例：

struct node{
	int key, val;
	node(int x, int y) {  //函数类型为结构体名
		key = x;
		val = y;
		//参数x赋值给key，y赋值给val
	}
};

构造函数之后可以对此类结构体进行赋值：

node n(1024, 2048);
node m = {First, Second};

2.3 例题

2.3.1 洛谷P1631 序列合并

【题目链接】

题目描述
有两个长度为 $N$ 的单调不降序列 $A,B$，在 $A,B$ 中各取一个数相加可以得到 $N^2$ 个和，求这 $N^2$ 个和中最小的 $N$ 个。

输入格式
第一行一个正整数 $N$；
第二行 $N$ 个整数 $A_{1\dots N}$。
第三行 $N$ 个整数 $B_{1\dots N}$。

输出格式
一行 $N$ 个整数，从小到大表示这 $N$ 个最小的和。

样例

样例输入

3
2 6 6
1 4 8

样例输出

3 6 7

提示
对于 $50\%$ 的数据，$N\le 10^3$。
对于 $100\%$ 的数据，$1\le N\le 10^5$，$1\le a_i,b_i\le 10^9$。

2.3.2 思路一

枚举 $N^2$ 种组合方案。时间复杂度为 $O(n^2)$。

降低时间复杂度方法：对 $A$ 和 $B$ 升序排序。

• 优先队列中元素数量 $<n$： 放入 a[i]+a[j]。
• 优先队列中元素数量 $\ge n$：如果堆顶元素小于a[i]+a[j]，删除堆顶元素，放入a[i]+a[j]；如果不小于，因为$A_i+B_j<A_i+B_{j\dots n}$，所以结束循环。

AC代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
typedef long long ll;
int n;
ll a[N], b[N], c[N];
priority_queue<ll> q;  //优先队列
int main() {
	cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int j = 1; j <= n; j++) cin >> b[j];
    sort(a + 1, a + n + 1);  //排序
    sort(a + 1, a + n + 1);
    for (int i = 1; i <= n; i++) {
    	for (int j = 1; j <= n; j++) {
    		if (q.size() < n) {   //元素少于n，放入
    			q.push(a[i] + b[j]);
			} else {
				if (a[i] + b[j] < q.top()) {   //a[i]+a[j]较小，替换队列中的较大值
					q.pop();
					q.push(a[i] + b[j]);
				} else {
					break;   //后面的结果必然越来越大，结束循环
				}
			}
		}
	}
	for (int i = n; i >= 1; i--) {
		c[i] = q.top();
		q.pop();
	}
	for (int i = 1; i <= n; i++) cout << c[i] << " ";
	return 0;
}

2.3.3 思路二

定义结构体，包含三个值：

1. $x$，在有序的$A$序列中的编号
2. $y$，在有序的$B$序列中的编号
3. $val$，$A_x+B_y$的值

类似 bfs 的做法：

1. 首先在优先队列中放入 { 1 , 1 , A 1 + B 1 } \{1,1,A_1+B_1\} {1,1,A1​+B1​} 。
2. 每次输出$val$最小的，删除，然后放入 { x , y , A x + 1 + B y } \{x,y,A_{x+1}+B_y\} {x,y,Ax+1​+By​} 和 { x , y , A x + B y + 1 } \{x,y,A_x+B_{y+1}\} {x,y,Ax​+By+1​}（用 map 记录是否重复）。
3. $n$次循环。

AC代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 10;
ll n, a[N], b[N];
struct node{
	int x, y;
	ll val;
	bool operator<(const node& f) const {return val > f.val; }  //重载运算符，在优先队列中把val值小作为优先级
	node(int a, int b, ll c) {x = a; y = b; val = c; }  //构造函数
};
priority_queue<node> q;   //优先队列，node类型
map<pair<int, int>, bool> mp;  //map去重使用
int main() {
    cin >> n;
    for (int i = 1; i <= n; i++)  cin >> a[i];
    for (int i = 1; i <= n; i++) cin >> b[i];
	sort(a + 1, a + n + 1);      //排序
	sort(b + 1, b + n + 1);
	q.push({1, 1, a[1] + b[1]});   //放入起始点{1, 1, a[1] + b[1]}
	while (n--) {
		int x = q.top().x, y = q.top().y;
		cout << q.top().val << " ";
		q.pop();
		if (!mp[make_pair(x + 1, y)]) {     //没用重复，放入{x + 1, y, a[x + 1] + b[y]}
			q.push({x + 1, y, a[x + 1] + b[y]});
			mp[make_pair(x + 1, y)] = true;   //标记
		}
		if (!mp[make_pair(x, y + 1)]) {    //没用重复，放入{x, y + 1, a[x] + b[y + 1]}
			q.push({x, y + 1, a[x] + b[y + 1]});
			mp[make_pair(x, y + 1)] = true;   //标记
		}
	}
	return 0;
}