使用Priority_queue中遇到的问题

在一个下午，我刷到了一个题。里面需要使用一个小根堆，然而里面的需要存的是一个类（或者结构体），堆的排序方式是按照这个类的第三个int类型的成员进行排序，这样当然要重载小于大于符号，于是我就写，竟然不知不觉的搞了半天，这要是在面试的时候基本上可以宣告 “你可以走了”
那我们来看一看我的心路历程：

class Solution {
public:
	int kthSmallest(vector<vector<int>>& matrix, int k) {
		priority_queue<v> que;
		for (int i = 0; i < matrix[0].size(); i++)  que.push(v(0, i, matrix[0][i]));
		//这大概就是我想要实现的效果，能有一个v的小跟堆
	}
};

首先，于是我就写 了一个类，但是类的居然是在这个Slution定义的，我可真牛逼啊，在一个类定义另外一个类
然后，我把v类移到了class Slution外面，但是重载怎么写呢？
其次我又把重载的符号写在了class Slution里面，我可真牛逼啊。肯定又是报错的三，其实这样的错误在IDE环境里面还好，但是放在网络判题器上面根本没法发现；
那么重载应该怎样写呢？
第一种：直接在全局重载这个类的小于符号。
其中最重要的还是要利用greater这个适配器作为介质来处理

class v {
public:
	int x;
	int y;
	int value;
	v(int x, int y, int value) :x(x), y(y), value(value) {};
};
bool operator>(const v& v1, const v& v2) {
	return v1.value > v2.value;
}
class Solution {
public:
	int kthSmallest(vector<vector<int>>& matrix, int k) {
		priority_queue<v, vector<v>, greater<v>> que;
		for (int i = 0; i < matrix[0].size(); i++)  que.push(v(0, i, matrix[0][i]));
		//这大概就是我想要实现的效果，能有一个v的小跟堆
	}
};

第二种 直接写个仿函数放在que里面；

class v {
public:
	int x;
	int y;
	int value;
	v(int x, int y, int value) :x(x), y(y), value(value) {};
};
class mycompare {
public:
	bool operator()(v& v1, v& v2) const {
		return v1.value > v2.value;
	}
};
class Solution {
public:
	int kthSmallest(vector<vector<int>>& matrix, int k) {
		priority_queue<v, vector<v>, mycompare> que;
		for (int i = 0; i < matrix[0].size(); i++)  que.push(v(0, i, matrix[0][i]));
		//这大概就是我想要实现的效果，能有一个v的小跟堆
	}
};

第三种方法 在类中重载 < 符号

class v {
public:
	int x;
	int y;
	int value;
	v(int x, int y, int value) :x(x), y(y), value(value) {};
	friend bool operator<(const v& v1, const v& v2) {
		return v1.value > v2.value;
	}
	
};

class Solution {
public:
	int kthSmallest(vector<vector<int>>& matrix, int k) {
		priority_queue<v> que;
		for (int i = 0; i < matrix[0].size(); i++)  que.push(v(0, i, matrix[0][i]));
		//这大概就是我想要实现的效果，能有一个v的小跟堆
	}
};

注意是< 而不是 > 不然会报错，因为系统默认的是小根堆less<>，如果想重载的是>符号，那么就是que就得写成：
priority_queue<v, vector, greater> que;
其实这种方法和第一种方法是类似的，都是重载了一下<符号

其他方法。是不行的：比如：
1.如果想直接在类中直接重载
那么重载函数必须加const

class v {
public:
	int x;
	int y;
	int value;
	v(int x, int y, int value) :x(x), y(y), value(value) {};
	bool operator<(const v& v2) const {
		return this->value > v2.value;
	}
	
};

2…第三个不能直接传递一个比较函数，而必须是仿函数；

以上都是写个struct/class放在里面，如果有时候想写个多元组，也可以用这种方式

auto tupleCmp = [](const auto& e1, const auto& e2) {
            auto&& [x1, y1, d1] = e1;
            auto&& [x2, y2, d2] = e2;
            return d1 > d2;
 };
priority_queue<tuple<int, int, int>, vector<tuple<int, int, int>>, decltype(tupleCmp)> q(tupleCmp);