力扣:优先队列合并K个升序链表以及衍生

优先队列合并K个升序链表

题目:
https://leetcode-cn.com/problems/merge-k-sorted-lists/
代码如下:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    struct node {
        ListNode *p;
        bool operator < (const node &nd) const {
            return p->val > nd.p->val;
        }
    };
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        /* 
        使用优先队列进行合并
        1.先把各个链表数组的首部入队
        2.从优先队列中取出最小值,然后把最小值链表的下一项入队(如果它有下一项的话)
        3.重复第二步即可
        */
        priority_queue<node> q;
        for(auto it:lists){
            if(it)
                q.push((node){it});
        }
        ListNode * head=new ListNode;
        head->next=nullptr;
        ListNode *p=head;
        while(q.size()){
            p->next=q.top().p;
            q.pop();

            p=p->next;
            if(p->next){
                q.push((node){p->next});
            }
        }
        p->next=nullptr;

        return head->next;
    }
};

---

衍生:
https://leetcode-cn.com/problems/k-th-smallest-prime-fraction/submissions/

class Solution {
public:
struct node{
        int zi,mu;
        double val;
        node(int z,int m,int zv,int mv){
            zi=z;
            mu=m;
            val=(double)zv/mv;
        }
        bool operator<(const node &nd) const{
            return val>nd.val;
        }
    };
    vector<int> kthSmallestPrimeFraction(vector<int>& arr, int k) { 
    /*
    由素数构成的数组,则组成的分数必不可能被约分
    i指针枚举分母,j指针枚举分子
    若指针i固定,指针j依次向右移动,对应的值是不断增大的
    因此,以分母为行,分子为列,我们可以得到一个从左到右递增,从上到下递减的一个二维数组
    (我们忽略这个从上到下递减这个条件)
    也就是说题目演变为,从一个二维数组中查找第k小的值,二维数组的每一行都是递增的
    */
    priority_queue<node> q;
    for(int i=1;i<arr.size();i++)
        q.push(node(0,i,arr[0],arr[i]));

    while(q.size()&&k--){
        node t=q.top();
        q.pop();

        if(!k) {
            vector<int> res;
            res.push_back(arr[t.zi]);
            res.push_back(arr[t.mu]);
            return res;
        }
        if(t.zi!=t.mu){
            q.push((node){t.zi+1,t.mu,arr[t.zi+1],arr[t.mu]});
        }
    }

    return vector<int>();
    }
};