LeetCode 5774 使用服务器处理任务(中等 优先队列)

LeetCode 5774 使用服务器处理任务

1. 题目

给你两个 下标从 0 开始 的整数数组 servers 和 tasks ，长度分别为 n​​​​​​ 和 m​​​​​​ 。servers[i] 是第 i​​​​​​​​​​ 台服务器的 权重 ，而 tasks[j] 是处理第 j​​​​​​ 项任务 所需要的时间（单位：秒）。
你正在运行一个仿真系统，在处理完所有任务后，该系统将会关闭。每台服务器只能同时处理一项任务。第 0 项任务在第 0 秒可以开始处理，相应地，第 j 项任务在第 j 秒可以开始处理。处理第 j 项任务时，你需要为它分配一台 权重最小 的空闲服务器。如果存在多台相同权重的空闲服务器，请选择 下标最小 的服务器。如果一台空闲服务器在第 t 秒分配到第 j 项任务，那么在 t + tasks[j] 时它将恢复空闲状态。
如果没有空闲服务器，则必须等待，直到出现一台空闲服务器，并 尽可能早 地处理剩余任务。 如果有多项任务等待分配，则按照 下标递增 的顺序完成分配。
如果同一时刻存在多台空闲服务器，可以同时将多项任务分别分配给它们。
构建长度为 m 的答案数组 ans ，其中 ans[j] 是第 j 项任务分配的服务器的下标。
返回答案数组 ans​​​​ 。
示例：
输入: servers = [3,3,2], tasks = [1,2,3,2,1,2]
输出：[2,2,0,2,1,2]
解释: 事件按时间顺序如下：
- 0 秒时，第 0 项任务加入到任务队列，使用第 2 台服务器处理到 1 秒。
- 1 秒时，第 2 台服务器空闲，第 1 项任务加入到任务队列，使用第 2 台服务器处理到 3 秒。
- 2 秒时，第 2 项任务加入到任务队列，使用第 0 台服务器处理到 5 秒。
- 3 秒时，第 2 台服务器空闲，第 3 项任务加入到任务队列，使用第 2 台服务器处理到 5 秒。
- 4 秒时，第 4 项任务加入到任务队列，使用第 1 台服务器处理到 5 秒。
- 5 秒时，所有服务器都空闲，第 5 项任务加入到任务队列，使用第 2 台服务器处理到 7 秒。。
提示：servers.length == n ，tasks.length == m，1 <= n, m <= 2 * 105，1 <= servers[i], tasks[j] <= 2 * 105

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/process-tasks-using-servers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.题解

        使用服务器处理任务，很明显有两个服务器，第一个表示正在工作的服务器，第二个表示空闲的服务器，我们对每一个任务来说，都需要从空闲服务器中取出权重最小的一台，如果权重一样就需要取下标更小的服务器，所以空闲服务器里面可以使用有限队列来保存，保存的规则就是按照权重排序，其次是按照下标排序，而工作服务器仅按照时间排序即可，因为每次都会尝试从工作服务器中取出工作完毕的服务器放入空闲服务器。

• 方法1： 定义serverTask类表示服务器，使用两个有限队列PriorityQueue分别表示工作和空闲服务器，代码如下

//定义服务器
class serverTask{
    int serverId;//id
    int serverQuality;//权重
    long serverTime;//结束时间
    serverTask(int serverId, int serverQuality, long serverTime){
        this.serverId = serverId;
        this.serverQuality = serverQuality;
        this.serverTime = serverTime;
    }
}
class Solution {
    public int[] assignTasks(int[] servers, int[] tasks) {
        int[] taskId = new int[tasks.length];
        //工作服务器，仅按照结束时间排序
        PriorityQueue<serverTask> TaskQueue = new PriorityQueue<>((o1, o2) -> {return o1.serverTime > o2.serverTime ? 1 : -1;});
        //空闲服务器，首先按照权重排序，其次按照id排序；
        PriorityQueue<serverTask> freeQueue = new PriorityQueue<>((o1, o2) -> {if(o1.serverQuality == o2.serverQuality) return o1.serverId - o2.serverId; return o1.serverQuality - o2.serverQuality;});
        //先将所有的服务器入工作服务器。
        for(int i = 0; i < servers.length; i++){
            TaskQueue.add(new serverTask(i, servers[i], 0));
        }
        long curTime = 0; // 当前时间
        for(int i = 0; i < tasks.length; i++){
            //每次的任务都从i开始，需要与curTime做比较；
            curTime = Math.max(curTime, i);
            //从任务服务器中拿出工作完成的服务器，满足的条件是完成时间小于等于curTime
            while(!TaskQueue.isEmpty() && TaskQueue.peek().serverTime <= curTime){
                freeQueue.add(TaskQueue.poll());
            }
            //如果当前空闲服务器为空，则必须等待工作服务器
            while(freeQueue.isEmpty()){
                //更新当前的时间为最快结束的服务器的结束时间。
                curTime = TaskQueue.peek().serverTime;
                //重新获取服务器
                while(!TaskQueue.isEmpty() && TaskQueue.peek().serverTime <= curTime){
                    freeQueue.add(TaskQueue.poll());
                }
            }
            //从空闲服务器中拿取服务器，更新工作时间，并将该服务器重新放入工作服务器。
            serverTask currentTask = freeQueue.poll();
            taskId[i] = currentTask.serverId; //当前任务所使用的服务器id
            //放入工作服务器
            TaskQueue.add(new serverTask(currentTask.serverId, currentTask.serverQuality, curTime + tasks[i]));
        }
        return taskId;
    }
}