力扣 506. 相对名次，703. 数据流中的第 K 大元素，23. 合并 K 个升序链表，215. 数组中的第K个最大元素，264. 丑数 II

506. 相对名次

题目

给你一个长度为 n 的整数数组 score ，其中 score[i] 是第 i 位运动员在比赛中的得分。所有得分都 互不相同 。

运动员将根据得分 决定名次 ，其中名次第 1 的运动员得分最高，名次第 2 的运动员得分第 2 高，依此类推。运动员的名次决定了他们的获奖情况：

名次第 1 的运动员获金牌 “Gold Medal” 。
名次第 2 的运动员获银牌 “Silver Medal” 。
名次第 3 的运动员获铜牌 “Bronze Medal” 。
从名次第 4 到第 n 的运动员，只能获得他们的名次编号（即，名次第 x 的运动员获得编号 “x”）。
使用长度为 n 的数组 answer 返回获奖，其中 answer[i] 是第 i 位运动员的获奖情况。

提示：
n == score.length
1 <= n <= 104
0 <= score[i] <= 106
score 中的所有值 互不相同

AC代码

class Solution {
public:
    vector<string> findRelativeRanks(vector<int>& score) {
        priority_queue<int, vector<int>, less<int> >q;	// 大顶堆
        // priority_queue<int>q;  同上
        for(auto x : score) q.push(x);
        int d=1,num;
        string s;
        map<int,string>mp;
        vector<string>res;
        while(!q.empty())
        {
            int t=q.top(); // 当前最大值
            q.pop();
            if(d==1)    mp[t]="Gold Medal";
            else if(d==2)   mp[t]="Silver Medal";
            else if(d==3)   mp[t]="Bronze Medal";
            else
            {
                num=d;
                s.clear();
                s=to_string(num);// int类型 转 string类型
                mp[t]=s;
            }
            d++; // 移动名次
        }
        for(auto x : score)    res.push_back(mp[x]);
        return res;
    }
};

703. 数据流中的第 K 大元素

题目

设计一个找到数据流中第 k 大元素的类（class）。注意是排序后的第 k 大元素，不是第 k 个不同的元素。

请实现 KthLargest 类：

KthLargest(int k, int[] nums) 使用整数 k 和整数流 nums 初始化对象。
int add(int val) 将 val 插入数据流 nums 后，返回当前数据流中第 k 大的元素。

提示：
1 <= k <= 10^4
0 <= nums.length <= 10^4
-10^4 <= nums[i] <= 10^4
-10^4 <= val <= 10^4
最多调用 add 方法 10^4 次
题目数据保证，在查找第 k 大元素时，数组中至少有 k 个元素

AC代码

class KthLargest {
public:
    priority_queue<int, vector<int>, greater<int> >q; // 小顶堆
    int t;
    KthLargest(int k, vector<int>& nums) {
        t=k; // 更新 第几位 的位数
        for(auto x : nums)  add(x);	// 输入数
    }
    
    int add(int val) {
        q.push(val);
        if(q.size()>t)  q.pop(); //出队 维护最大值为数组第 k 大的元素 
        return q.top(); // 返回第 k 大的元素 
    }
};

/**
 * Your KthLargest object will be instantiated and called as such:
 * KthLargest* obj = new KthLargest(k, nums);
 * int param_1 = obj->add(val);
 */

23. 合并 K 个升序链表

题目

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

提示：

k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4

AC代码

// 利用优先队列总能返回最值的性质
/**
 * 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 cmp{
        bool operator()(ListNode* l1,ListNode* l2) // 比较函数
            return l1->val > l2->val;
    };
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<ListNode*, vector<ListNode*>, cmp> heap;
        auto dummy =new ListNode(-1), tail=dummy; // 设置空节点
        for(auto l : lists)    if(l)   heap.push(l); // 输入优先队列
        while(heap.size())
        {
            auto p = heap.top();
            heap.pop();
            tail= tail->next =p;
            if(p->next) heap.push(p->next);
        }
        return dummy->next; 
    }
};

215. 数组中的第K个最大元素

题目

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

提示：

1 <= k <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4

AC代码

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
    	// sort 法
        // sort(nums.begin(),nums.end());
        // return nums[nums.size()-k];

		// 优先队列 法
        priority_queue<int, vector<int>, less<int> >q;
        for(auto x : nums)  q.push(x);
        while(nums.size()-q.size()<k-1)    q.pop(); // 删除 k-1 个数
        return q.top();
    }
};

264. 丑数 II

题目

给你一个整数 n ，请你找出并返回第 n 个 丑数 。

丑数 就是质因子只包含 2、3 和 5 的正整数。

提示：

1 <= n <= 1690

AC代码

// 由质因子只包含 2、3 和 5 的正整数得 丑数 为 2的次幂，3的次幂，5的次幂
class Solution {
public:
    int nthUglyNumber(int n) {
        vector<long long> f(n + 1);
        f[1] = 1;
        int a=1,b=1,c=1;
        for (int i = 2; i <= n; i ++) {
            int res=min(2*f[a],min(3*f[b],5*f[c]));
            f[i]=res;
            if(res==f[a]*2) a++;
            if(res==f[b]*3) b++;
            if(res==f[c]*5) c++;
        }
        return f[n];
    }
};