LeetCode | 786. K-th Smallest Prime Fraction BFS堆排序

A sorted list A contains1, plus some number of primes.  Then, for every p < q in the list, weconsider the fraction p/q.

What is the K-thsmallest fraction considered?  Return your answer as an array of ints,where answer[0] = p and answer[1] = q.

Examples:

Input: A = [1, 2, 3, 5], K = 3

Output: [2, 5]

Explanation:

The fractions to be considered in sorted order are:

1/5, 1/3, 2/5, 1/2, 3/5, 2/3.

The third fraction is 2/5.

 

Input: A = [1, 7], K = 1

Output: [1, 7]

Note:

• A will have length between 2 and 2000.
• Each A[i] will be between 1 and 30000.
• K will be between 1 and A.length * (A.length + 1) / 2.

这一题我是使用BFS加小根堆堆排序实现的，小根堆可以使用优先级队列priority_queue实现

以1,2,3,5 K为3为例介绍我的方法，首先打个表

1/2
1/3	2/3
1/5	2/5	3/5

 

观察以上表格可以发现，在表格中每一个格子向上走和向右走数值都会变大，将小根堆初始化为1/5,2/5,3/5，然后每次从中取最小的一个数，第一步取的是1/5，然后取1/5上边和右边没有访问过的数，这里为1/3，将它加入小根堆

然后从小根堆里取最小的数，将这个数表格中上边和右边没有访问过的数加入小根堆，直到取得第K个数就是需要的分数

这里还有一个知识点就是有限级队列是priority_queue，其头文件是queue，在初始化的时候需要使用priority_queue<node,vector<node> ,cmp>，也就是说优先级队列要么一个参数，要么三个参数，两个参数是不可行的，对于cmp而言，重载()，默认是<，是大根堆，要是重载为>的话就会变成小根堆，优先级队列是push，top，pop来实现的

class Solution {
public:
struct node
{
	int denominator; int denominatorIndex;
	int molecule; int moleculeIndex;
	node(int a=0,int b=0,int c=0,int d=0) : denominator(a), denominatorIndex(b), molecule(c), moleculeIndex(d) {}
};
struct cmp
{
	bool operator () (node a, node b)
	{
		return a.molecule*b.denominator > a.denominator*b.molecule;
	}
};
vector<int> kthSmallestPrimeFraction(vector<int>& A, int K) {
	int N = A.size(); int x, y;
	priority_queue<node,vector<node>,cmp> theQ;
	vector<vector<bool>> vst(A.size(), vector<bool>(A.size(), false));
	for (int i = 0; i < A.size()-1; i++)
	{
		theQ.push(node(A[N-1], N-1, A[i], i)); vst[i][N - 1] = true;
	}
	node tmp;
	while (K!=0)
	{
		tmp = theQ.top(); theQ.pop(); K--;
		x = tmp.moleculeIndex + 1; y = tmp.denominatorIndex ;
		if (x < y && !vst[x][y]) { theQ.push(node(A[y], y, A[x], x)); vst[x][y] = true;}
		x = tmp.moleculeIndex; y = tmp.denominatorIndex-1;
		if (y > x && !vst[x][y]) { theQ.push(node(A[y], y, A[x], x)); vst[x][y] = true;
		}
	}
	vector<int> result;
	result.push_back(tmp.molecule);
	result.push_back(tmp.denominator);
	return result;
}
};