leetcode786第k个最小的素数（困难）

方法一：查找比他小的数字，双指针，分母顺序查找，分子二分查找

class Solution {
public:
    //小于m的个数大于等于K返回true
    bool satisfy(vector<int> a, double m, int K) {
        //由于a数组是有序的，所以可以采取分母顺序查找，分子二分查找的方式，效率高一些
        int count = 0;
        for (int i = 1; i < a.size(); i++){ //分母
            int l = -1, r = i;
            while (l + 1 < r){
                int mid = (l + r) / 2;
                if (1.0 * a[mid] / a[i] < m) l = mid;
                else r = mid;
            }
            count += (l + 1);
        }
        return count >= K;
    }
    vector<int> kthSmallestPrimeFraction(vector<int>& A, int K) {
        //即存在0到1的小数，小于他的分数正好有k个，所以存在二分的思想,R为最终值
        //思想：小于他的个数等于正好是k，然后找小于该值的最大分数即是结果
        // A[i] / A[j] 是整型， 需要改成浮点型A[i] * 1.0 / A[j]！！
        // 因为A[i] 是1-30000 ，需要R - L比1e-4小两个量级以上保证精度！！
        double l = 0.0, r = 1.0;
        while (r - l > 1e-7){  //实数的终止条件是R - L > 1e-7，而不是L + 1 < R!!!!!
            //7以上都可以，6不行，大于两个量级！！！
            double mid = (l + r) / 2.0;
            if (satisfy(A, mid, K)){ 
                r = mid;
            }else {
                l = mid;
            }
        }
        vector<int> result(2);
        double _max = 0.0;
        for (int i = 1; i < A.size(); i++){  //分母
            int Left = -1, Right = i; //分子，都在边界之外，注意讨论边界，即Left为-1时！！！
            while (Left + 1 < Right){
                int mid = (Left + Right) / 2;
                if (1.0 * A[mid] / A[i] <=  r) Left = mid; //返回Left
                else Right = mid;
            }
            if (Left >= 0 && 1.0 * A[Left] / A[i] > _max){ //别忘了Left小于0的情况，而且要把Left >= 0放到前面，不然会发生数组下标小于0！！！
                _max = 1.0 * A[Left] / A[i]; 
                result[0] = A[Left];
                result[1] = A[i];
            }
        }
        return result;
    }
};

方法二：1/3 小于则1/大于3的数 也一定小于，分母增加分子也在增加

class Solution {
public:
    bool satisfy(vector<int> a, double m, int K) {
        //思想：1/3 小于则1/大于3的数也一定小于，分母增加分子也在增加
        int count = 0;
        int j = 0;
        for (int i = 1; i < a.size(); ++i){ //分母
            for (; j < i && 1.0 * a[j] / a[i] < m; j++){ //分子
            }
            count += j;
        }
        return count >= K;
    }
    vector<int> kthSmallestPrimeFraction(vector<int>& A, int K) {

        double l = 0.0, r = 1.0;
        while (r - l > 1e-7){  
            double mid = (l + r) / 2.0;
            if (satisfy(A, mid, K)){ 
                r = mid;
            }else {
                l = mid;
            }
        }
        vector<int> result(2, 0);
        double _max = 0.0;
        int j = 0;
        for (int i = 1; i < A.size(); i++){  //分母
            for (; j < i && 1.0 * A[j] / A[i] < r; j++){ //分子
            }
            if (j > 0 && 1.0 * A[j - 1] / A[i] > _max){
                _max = 1.0 * A[j - 1] / A[i];
                result[0] = A[j - 1];
                result[1] = A[i];
            }
        }
        return result;
    }
};

方法三：排序

class Solution {
public:
    vector<int> kthSmallestPrimeFraction(vector<int>& arr, int k) {

        vector<pair<int, int>> v;
        int n = arr.size();
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                v.push_back({arr[i], arr[j]});
                //临时pair可以用{}
            }
        }
        sort(v.begin(), v.end(), [](const pair<int, int> &p1, const pair<int, int> &p2){
            return p1.first * p2.second < p1.second * p2.first;
        });
        return {v[k - 1].first, v[k - 1].second};
        //临时vector可以用{}
    }
};

注意：排序时，如果使用double。浮点数运算会很耗时。

方法四：优先队列

class Solution {
public:
    struct cmp{
        bool operator() (pair<int, int> p1, pair<int, int> p2) {
            return p1.first * p2.second < p1.second * p2.first;
        }
    };
    vector<int> kthSmallestPrimeFraction(vector<int>& arr, int k) {

        priority_queue<pair<int, int>, vector<pair<int, int>>, cmp> pq;
        int n = arr.size();
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                if (pq.size() < k) {
                    pq.push({arr[i], arr[j]});
                }
                else if (arr[i] * pq.top().second < arr[j] * pq.top().first) {
                    pq.pop();
                    pq.push({arr[i], arr[j]});
                }
            }
        }
        return {pq.top().first, pq.top().second};
    }
};