优先队列解决多个升序列表的第K小

题目是力扣
P786.第K个最小的素数分数
第一眼看数据范围只有10³，直接想暴力搜索排序，每一对数据可以用到pair，用vector储存每一对pair，自定义函数cmp重载<符，比较两个分数大小的时候直接比较a的分子乘b的分母和b的分子乘a的分母的大小即可。

class Solution {
public:
static bool cmp(const pair<int,int>&a,const pair<int,int>&b){
    return (a.first*b.second)<(b.first*a.second);
}

    vector<int> kthSmallestPrimeFraction(vector<int>& arr, int k) {
        vector<pair<int,int>>ans;
        int n=arr.size();
        for(int i=0;i<n;i++){
            int j=i+1;
            while(j<n){
                ans.push_back({arr[i],arr[j]});
                j++;
            }
        }
        sort(ans.begin(),ans.end(),cmp);
        vector<int>res;
        res.push_back(ans[k-1].first);
        res.push_back(ans[k-1].second);
        return res;
    }
};

跑出来发现太慢了，因为我们只需要取第K小的数字，并不需要全部排序，浪费了许多运算，而且我们未用到数组递增的性质。因此我们可以考虑采用优先队列、多路归并的方法。
考虑由[1,2,3,5]产生的所有分数，按照分母的不同大小分成三个列表

• 1/2
• 1/3，2/3
• 1/5，2/5，3/5

很容易注意到，每一个列表都是从左到右递增的，我们首先将每个分类中最小的分数入队，优先队列底层是一个小顶堆，顶部元素最小；然后出队最小的分数，将和该分数分母一样但分子更大的下一个分数入队，这样可以保证每次出队的元素一定是最小的；进行k-1次操作后；优先队列首部就是最小的第k个元素了。

class Solution {
public:
	struct cmp{ //比较模板
        bool operator()(const pair<int,int>&a,const pair<int,int>&b){
            return (a.first*b.second)>(b.first*a.second); //大的下沉，是小顶堆
        }
    };

    vector<int> kthSmallestPrimeFraction(vector<int>& arr, int k) {
        priority_queue<pair<int,int>,vector<pair<int,int>>,cmp> q;
        int n=arr.size();
        vector<int>ans;
        unordered_map<int,int>pos;
        for(int i=0;i<n;i++){
        	pos[arr[i]]=i; //记录以下每个数的位置
        }
        for(int i=1;i<n;i++){
        	q.push(make_pair(arr[0],arr[i])); //先把第一列入队
        }
        for(int i=0;i<k-1;i++){ //只需要执行k-1次即可
        	auto p=q.top();
        	q.pop();
        	q.push(make_pair(arr[pos[p.first]+1],p.second));
        }
        auto p=q.top();
        ans.push_back(p.first);
        ans.push_back(p.second);
        return ans;
    }
};

这个题和合并K个升序链表本质上是相同的，可以练习一下。

class Solution {
public:
    struct cmp{  //自定义比较模板
        bool operator()(const ListNode* a,const ListNode* b){
            return a->val>b->val; //大的往下沉，是小顶堆
        }
    };
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<ListNode*,vector<ListNode*>,cmp> pq;
        for(auto t:lists){
            if(t) pq.push(t);
        }
        ListNode* head=new ListNode();
        ListNode* ptr=head;
        while(pq.size()){ //以优先队列为空为结束条件
            ListNode* m=pq.top();
            pq.pop();
            ptr->next=m; //ptr连接整个链表
            ptr=m; //ptr后移
            if(m->next) pq.push(m->next); //还有下一个结点的话就往优先队列里面放
        }
        return head->next;
    }
};