[LeetCode 786.] K-th Smallest Prime Fraction
LeetCode 786. K-th Smallest Prime Fraction
一道经典题，给出两种经典解法。
题目描述
You are given a sorted integer array arr containing 1 and prime numbers, where all the integers of arr are unique. You are also given an integer k.
For every i and j where 0 <= i < j < arr.length, we consider the fraction arr[i] / arr[j].
Return the kth smallest fraction considered. Return your answer as an array of integers of size 2, where answer[0] == arr[i] and answer[1] == arr[j].
Example 1:
Input: arr = [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, and 2/3.
The third fraction is 2/5.
Example 2:
Input: arr = [1,7], k = 1
Output: [1,7]
Constraints:
- 2 <= arr.length <= 1000
- 1 <= arr[i] <= 3 * 104
- arr[0] == 1
- arr[i] is a prime number for i > 0.
- All the numbers of arr are unique and sorted in strictly increasing order.
- 1 <= k <= arr.length * (arr.length - 1) / 2
解题思路
第一种解法是使用堆，类似 LeetCode 373. Find K Pairs with Smallest Sums，需要自定义 comparator，参考前面的【priority_queue 自定义 comparator】这种写法，重点在于会自定义 comparator。
这俩有一个重点优化在于我们不需要把所有合法分数入队一遍，只需要根据分数的有序性质，入队头，然后按多路排序的思路每次出队再把自己的后继入队即可。
堆解法的空间复杂度 O(K)，时间复杂度 O(N+K+K*logK)。
第二种解法是使用二分查找，可能不是那么直观就能想到。首先分数的取值范围是 [0, 1]，我们用浮点数来搜索一个可能的上限值，使其满足比这个值小的分数恰好是 k 个。在统计比浮点数小的值的过程中，同时找出一个比浮点数小但距离最近的分数，这个分数就是所求。
二分查找空间复杂度 O(1)，时间复杂度是多少？每一轮确定搜索区间后的统计阶段，时间复杂度是 O(N*N)，那么搜索区间最多有几轮？
O(log1.0) 显然是错误的。要注意，这并不是一个整数区间，所以并不能认为是进行了O(区间长)的轮数。
我们注意到，我们搜索的 [l, r] 然后统计小于 m 的分数个数，本质上m的取值是在两个候选分数之间的“空隙”中，而每个“空隙”实际上最多进一次，空隙个数本质上看的是候选分数个数，所以轮数是 O(log(N*N))=O(logN)，总体时间复杂度 O(N*N*logN)。
参考代码
堆自定义 comparator 的解法
/*
* @lc app=leetcode id=786 lang=cpp
*
* [786] K-th Smallest Prime Fraction
*/
// @lc code=start
class Solution {
public:
vector<int> kthSmallestPrimeFraction(vector<int>& arr, int k) {
using PII = pair<int,int>;
auto cmp = [&](const PII& a, const PII& b) {
auto [i1, j1] = a;
auto [i2, j2] = b;
return (double)arr[i1]/arr[j1] > (double)arr[i2]/arr[j2];
};
priority_queue<PII, deque<PII>, decltype(cmp)> q(cmp);
int n = arr.size();
for (int j=n-1; j>=1 && n-j<=k; j--) {
q.emplace(0, j);
}
while (--k) {
auto [i, j] = q.top();
q.pop();
// if (i+1 < n) {
if (i+1 < j) {
q.emplace(i+1, j);
}
}
auto [i, j] = q.top();
return {arr[i], arr[j]};
} // AC
};
// @lc code=end
二分查找的解法
这里其实还可以进一步优化，比如统计 cnt 的时候每个分子对应的一系列分数是有序的，遇到临界值就可以跳出循环了。更进一步，搜索临界值也不必线性扫描，二分查找就可以，每一轮统计只需要 O(N*logN) 时间就可以了。
/*
* @lc app=leetcode id=786 lang=cpp
*
* [786] K-th Smallest Prime Fraction
*/
// @lc code=start
class Solution {
public:
vector<int> kthSmallestPrimeFraction(vector<int>& arr, int k) {
int n = arr.size();
int p, q;
double l = 0.0, r = 1.0;
while (l < r) {
double m = l + (r - l) / 2.0;
int cnt = 0;
double res = 0.0;
for (int i=0; i<n; i++) {
for (int j=i+1; j<n; j++) {
double f = (double)arr[i] / arr[j];
if (f < m) {
cnt ++;
if (res < f) {
res = f;
p = arr[i];
q = arr[j];
}
}
}
}
if (cnt == k) break;
else if (cnt < k) l = m;
else r = m;
}
return {p, q};
} // AC, vital
};
// @lc code=end
