列表

详情

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

你有 k 个服务器，编号为 0 到 k-1 ，它们可以同时处理多个请求组。每个服务器有无穷的计算能力但是 不能同时处理超过一个请求 。请求分配到服务器的规则如下：

给你一个 严格递增 的正整数数组 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]

 

提示：

原站题解

去查看

上次编辑到这里，代码来自缓存 点击恢复默认模板
class Solution { public: vector<int> busiestServers(int k, vector<int>& arrival, vector<int>& load) { } };

python3 解法, 执行用时: 372 ms, 内存消耗: 37.1 MB, 提交时间: 2023-06-12 09:52:59 

class Solution:
    def busiestServers(self, k: int, arrival: List[int], load: List[int]) -> List[int]:
        available = list(range(k))
        busy = []
        requests = [0] * k
        for i, (start, t) in enumerate(zip(arrival, load)):
            while busy and busy[0][0] <= start:
                _, id = heappop(busy)
                heappush(available, i + (id - i) % k)  # 利用 Python 负数取模变成同余的非负数的性质
            if available:
                id = heappop(available) % k
                requests[id] += 1
                heappush(busy, (start + t, id))
        maxRequest = max(requests)
        return [i for i, req in enumerate(requests) if req == maxRequest]

golang 解法, 执行用时: 252 ms, 内存消耗: 17.5 MB, 提交时间: 2023-06-12 09:52:37 

func busiestServers(k int, arrival, load []int) (ans []int) {
    available := redblacktree.NewWithIntComparator()
    for i := 0; i < k; i++ {
        available.Put(i, nil)
    }
    busy := hp{}
    requests := make([]int, k)
    maxRequest := 0
    for i, t := range arrival {
        for len(busy) > 0 && busy[0].end <= t {
            available.Put(busy[0].id, nil)
            heap.Pop(&busy)
        }
        if available.Size() == 0 {
            continue
        }
        node, _ := available.Ceiling(i % k)
        if node == nil {
            node = available.Left()
        }
        id := node.Key.(int)
        requests[id]++
        if requests[id] > maxRequest {
            maxRequest = requests[id]
            ans = []int{id}
        } else if requests[id] == maxRequest {
            ans = append(ans, id)
        }
        heap.Push(&busy, pair{t + load[i], id})
        available.Remove(id)
    }
    return
}

type pair struct{ end, id int }
type hp []pair
func (h hp) Len() int            { return len(h) }
func (h hp) Less(i, j int) bool  { return h[i].end < h[j].end }
func (h hp) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
func (h *hp) Push(v interface{}) { *h = append(*h, v.(pair)) }
func (h *hp) Pop() interface{}   { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }

java 解法, 执行用时: 106 ms, 内存消耗: 55.3 MB, 提交时间: 2023-06-12 09:51:02 

class Solution {
    public List<Integer> busiestServers(int k, int[] arrival, int[] load) {
        PriorityQueue<int[]> used = new PriorityQueue<>((a,b)->a[0]-b[0]);
        PriorityQueue<Integer> available = new PriorityQueue<>((a,b)->a-b);
        for(int i = 0; i < k; i++)
            available.add(i);
        int[] cnts = new int[k];
        for(int i = 0; i < arrival.length; i++) {
            int arr = arrival[i], duration = load[i];
            while(!used.isEmpty() && used.peek()[0] <= arr) {
                int[] cur = used.poll();
                available.add(i + ((cur[1] - i) % k + k) % k);
            }
            if(!available.isEmpty()) {
                int idx = available.poll() % k;
                cnts[idx]++;
                used.add(new int[]{arr + duration, idx});
            }
        }
        List<Integer> ans = new ArrayList<>();
        int m = 0;
        for(int i = 0; i < k; i++) {
            if(cnts[i] > m) {
                ans.clear();
                ans.add(i);
                m = cnts[i];
            } else if(cnts[i] == m) {
                ans.add(i);
            }
        }
        return ans;
    }
}

python3 解法, 执行用时: 448 ms, 内存消耗: 40.3 MB, 提交时间: 2023-06-12 09:50:43 

# 双优先队列
class Solution:
    def busiestServers(self, k: int, arrival: List[int], load: List[int]) -> List[int]:
        available, used, cnts = [i for i in range(k)], [], Counter()
        for i, (arr, duration) in enumerate(zip(arrival, load)):
            while used and used[0][0] <= arr:
                _, idx = heapq.heappop(used)
                # 唯一核心，让可用服务器按当前到达坐标i模k排序，且保证坐标模k同余
                heapq.heappush(available, i + (idx - i) % k)
            if available:
                idx = heapq.heappop(available) % k
                cnts[idx] += 1
                heapq.heappush(used, (arr + duration, idx))
        return [k for k, v in cnts.items() if v == m] if (m := max(cnts.values())) else []

上一题

© 2025 leetcode.cn