模拟-6170. 会议室 III

问题描述

给你一个整数 n ，共有编号从 0 到 n - 1 的 n 个会议室。
给你一个二维整数数组 meetings ，其中 meetings[i] = [starti, endi] 表示一场会议将会在 半闭 时间区间 [starti, endi) 举办。所有 starti 的值 互不相同 。
会议将会按以下方式分配给会议室：
每场会议都会在未占用且编号 最小 的会议室举办。
如果没有可用的会议室，会议将会延期，直到存在空闲的会议室。延期会议的持续时间和原会议持续时间 相同 。
当会议室处于未占用状态时，将会优先提供给原 开始 时间更早的会议。
返回举办最多次会议的房间 编号 。如果存在多个房间满足此条件，则返回编号 最小 的房间。
半闭区间 [a, b) 是 a 和 b 之间的区间，包括 a 但 不包括 b 。
示例 1：
输入：n = 2, meetings = [[0,10],[1,5],[2,7],[3,4]]
输出：0
解释：

• 在时间 0 ，两个会议室都未占用，第一场会议在会议室 0 举办。
• 在时间 1 ，只有会议室 1 未占用，第二场会议在会议室 1 举办。
• 在时间 2 ，两个会议室都被占用，第三场会议延期举办。
• 在时间 3 ，两个会议室都被占用，第四场会议延期举办。
• 在时间 5 ，会议室 1 的会议结束。第三场会议在会议室 1 举办，时间周期为 [5,10) 。
• 在时间 10 ，两个会议室的会议都结束。第四场会议在会议室 0 举办，时间周期为 [10,11) 。
  会议室 0 和会议室 1 都举办了 2 场会议，所以返回 0 。
  示例 2：

输入：n = 3, meetings = [[1,20],[2,10],[3,5],[4,9],[6,8]]
输出：1
解释：

• 在时间 1 ，所有三个会议室都未占用，第一场会议在会议室 0 举办。
• 在时间 2 ，会议室 1 和 2 未占用，第二场会议在会议室 1 举办。
• 在时间 3 ，只有会议室 2 未占用，第三场会议在会议室 2 举办。
• 在时间 4 ，所有三个会议室都被占用，第四场会议延期举办。
• 在时间 5 ，会议室 2 的会议结束。第四场会议在会议室 2 举办，时间周期为 [5,10) 。
• 在时间 6 ，所有三个会议室都被占用，第五场会议延期举办。
• 在时间 10 ，会议室 1 和 2 的会议结束。第五场会议在会议室 1 举办，时间周期为 [10,12) 。
  会议室 1 和会议室 2 都举办了 2 场会议，所以返回 1 。

提示：
1 <= n <= 100
1 <= meetings.length <= 105
meetings[i].length == 2
0 <= starti < endi <= 5 * 105
starti 的所有值 互不相同

问题求解

用两个堆来模拟进程即可。

class Solution:
    def mostBooked(self, n: int, meetings: List[List[int]]) -> int:
        cnt = [0] * n
        idle, used = list(range(n)), [] # used中存放了当前使用的结束时间和编号，按照结束时间递增排序
        meetings.sort()
        for st, end in meetings:
            while used and used[0][0] <= st:
                heappush(idle, heappop(used)[1])
            if idle:
                i = heappop(idle)
            else:
                e, i = heappop(used)
                end += e - st
            cnt[i] += 1
            heappush(used, (end, i))
        res = 0
        for i, c in enumerate(cnt):
            if c > cnt[res]:
                res = i
        return res

相似问题

1882. 使用服务器处理任务

问题描述

给你两个 下标从 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​​​​ 。
示例 1：
输入：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 秒。
  示例 2：
  输入：servers = [5,1,4,3,2], tasks = [2,1,2,4,5,2,1]
  输出：[1,4,1,4,1,3,2]
  解释：事件按时间顺序如下：
• 0 秒时，第 0 项任务加入到任务队列，使用第 1 台服务器处理到 2 秒。
• 1 秒时，第 1 项任务加入到任务队列，使用第 4 台服务器处理到 2 秒。
• 2 秒时，第 1 台和第 4 台服务器空闲，第 2 项任务加入到任务队列，使用第 1 台服务器处理到 4 秒。
• 3 秒时，第 3 项任务加入到任务队列，使用第 4 台服务器处理到 7 秒。
• 4 秒时，第 1 台服务器空闲，第 4 项任务加入到任务队列，使用第 1 台服务器处理到 9 秒。
• 5 秒时，第 5 项任务加入到任务队列，使用第 3 台服务器处理到 7 秒。
• 6 秒时，第 6 项任务加入到任务队列，使用第 2 台服务器处理到 7 秒。
  提示：
  servers.length == n
  tasks.length == m
  1 <= n, m <= 2 * 105
  1 <= servers[i], tasks[j] <= 2 * 105

问题求解

class Solution:
    def assignTasks(self, servers: List[int], tasks: List[int]) -> List[int]:
        n, m = len(servers), len(tasks)
        res = [0] * m
        idle, used = [], []
        for i, s in enumerate(servers):
            heappush(idle, (s, i))
        tasks = [[i, i + t] for i, t in enumerate(tasks)]
        for k in range(m):
            st, end = tasks[k]
            while used and used[0][0] <= st:
                curr = heappop(used)
                heappush(idle, (servers[curr[2]], curr[2]))
            if idle:
                s, i = heappop(idle)
            else:
                e, w, i = heappop(used)
                end += e - st
            heappush(used, (end, servers[i], i))
            res[k] = i
        return res

1606. 找到处理最多请求的服务器

问题描述

你有 k 个服务器，编号为 0 到 k-1 ，它们可以同时处理多个请求组。每个服务器有无穷的计算能力但是 不能同时处理超过一个请求 。请求分配到服务器的规则如下：
第 i （序号从 0 开始）个请求到达。
如果所有服务器都已被占据，那么该请求被舍弃（完全不处理）。
如果第 (i % k) 个服务器空闲，那么对应服务器会处理该请求。
否则，将请求安排给下一个空闲的服务器（服务器构成一个环，必要的话可能从第 0 个服务器开始继续找下一个空闲的服务器）。比方说，如果第 i 个服务器在忙，那么会查看第 (i+1) 个服务器，第 (i+2) 个服务器等等。
给你一个 严格递增 的正整数数组 arrival ，表示第 i 个任务的到达时间，和另一个数组 load ，其中 load[i] 表示第 i 个请求的工作量（也就是服务器完成它所需要的时间）。你的任务是找到 最繁忙的服务器 。最繁忙定义为一个服务器处理的请求数是所有服务器里最多的。
请你返回包含所有 最繁忙服务器 序号的列表，你可以以任意顺序返回这个列表。

示例 1：
输入：k = 3, arrival = [1,2,3,4,5], load = [5,2,3,3,3]
输出：[1]
解释：
所有服务器一开始都是空闲的。
前 3 个请求分别由前 3 台服务器依次处理。
请求 3 进来的时候，服务器 0 被占据，所以它被安排到下一台空闲的服务器，也就是服务器 1 。
请求 4 进来的时候，由于所有服务器都被占据，该请求被舍弃。
服务器 0 和 2 分别都处理了一个请求，服务器 1 处理了两个请求。所以服务器 1 是最忙的服务器。
示例 2：
输入：k = 3, arrival = [1,2,3,4], load = [1,2,1,2]
输出：[0]
解释：
前 3 个请求分别被前 3 个服务器处理。
请求 3 进来，由于服务器 0 空闲，它被服务器 0 处理。
服务器 0 处理了两个请求，服务器 1 和 2 分别处理了一个请求。所以服务器 0 是最忙的服务器。
示例 3：
输入：k = 3, arrival = [1,2,3], load = [10,12,11]
输出：[0,1,2]
解释：每个服务器分别处理了一个请求，所以它们都是最忙的服务器。
示例 4：
输入：k = 3, arrival = [1,2,3,4,8,9,10], load = [5,2,10,3,1,2,2]
输出：[1]
示例 5：
输入：k = 1, arrival = [1], load = [1]
输出：[0]

提示：
1 <= k <= 105
1 <= arrival.length, load.length <= 105
arrival.length == load.length
1 <= arrival[i], load[i] <= 109
arrival 保证 严格递增 。

问题求解

from sortedcontainers import SortedList
class Solution:
    def busiestServers(self, k: int, arrival: List[int], load: List[int]) -> List[int]:
        n = len(arrival)
        tasks = [[arrival[i], arrival[i] + load[i]] for i in range(n)]
        cnt = [0] * k
        idle, used = SortedList(list(range(k))), []
        for i, (st, end) in enumerate(tasks):
            while used and used[0][0] <= st:
                idle.add(heappop(used)[1])
            if idle:
                idx = idle.bisect_left(i % k)
                if idx == len(idle): idx = 0
                cnt[idle[idx]] += 1
                heappush(used, (end, idle[idx]))
                idle.pop(idx)
        ma = max(cnt)
        return [i for i in range(k) if cnt[i] == ma]