Find servers that handled most number of requests

Array Heap (Priority Queue) Simulation Ordered Set

45.2% acceptance

Feb 25, 2026

671

You have k servers numbered from 0 to k-1 that are being used to handle multiple requests simultaneously. Each server has infinite computational capacity but cannot handle more than one request at a time. The requests are assigned to servers according to a specific algorithm: The ith (0-indexed) request arrives. If all servers are busy, the request is dropped (not handled at all). If the (i % k)th server is available, assign the request to that server. Otherwise, assign the request to the next available server (wrapping around the list of servers and starting from 0 if necessary). You are given a strictly increasing array arrival of positive integers, where arrival[i] represents the arrival time of the ith request, and another array load, where load[i] represents the load of the ith request (the time it takes to complete). Your goal is to find the busiest server(s). A server is considered busiest if it handled the most number of requests successfully among all the servers. Return a list containing the IDs (0-indexed) of the busiest server(s). You may return the IDs in any order.

Solution

Rust

Time O(n²)

Space O(n)

LeetCode

solution.rs

use std::collections::BTreeSet;
use std::collections::BinaryHeap;
use std::cmp::Reverse;

impl Solution {
  pub fn busiest_servers(k: i32, arrival: Vec<i32>, load: Vec<i32>) -> Vec<i32> {
    let k = k as usize;
    let n = arrival.len();
    let mut count = vec![0i64; k];
    // min-heap: (end_time, server_id)
    let mut busy: BinaryHeap<Reverse<(i64, usize)>> = BinaryHeap::new();
    // available servers in sorted order
    let mut available: BTreeSet<usize> = (0..k).collect();

    for i in 0..n {
      let t = arrival[i] as i64;
      // free up servers that finished before current arrival
      while let Some(&Reverse((end, sid))) = busy.peek() {
        if end <= t {
          busy.pop();
          available.insert(sid);
        } else {
          break;
        }
      }
      if available.is_empty() {
        continue;
      }
      let preferred = i % k;
      // find first available >= preferred, or wrap around
      let chosen = if let Some(&sid) = available.range(preferred..).next() {
        sid
      } else {
        *available.iter().next().unwrap()
      };
      available.remove(&chosen);
      count[chosen] += 1;
      busy.push(Reverse((t + load[i] as i64, chosen)));
    }

    let max_c = *count.iter().max().unwrap();
    count.iter().enumerate()
      .filter(|&(_, &c)| c == max_c)
      .map(|(i, _)| i as i32)
      .collect()
  }
}