1606. Find Servers That Handled Most Number of Requests LeetCode Solution

Last updated: February 24, 2025

In this guide, you will get 1606. Find Servers That Handled Most Number of Requests LeetCode Solution with the best time and space complexity. The solution to Find Servers That Handled Most Number of Requests problem is provided in various programming languages like C++, Java, and Python. This will be helpful for you if you are preparing for placements, hackathons, interviews, or practice purposes. The solutions provided here are very easy to follow and include detailed explanations.

Problem Statement
Complexity Analysis
Find Servers That Handled Most Number of Requests solution in C++
Find Servers That Handled Most Number of Requests solution in Java
Find Servers That Handled Most Number of Requests solution in Python
Additional Resources

1606. Find Servers That Handled Most Number of Requests LeetCode Solution image

Problem Statement of Find Servers That Handled Most Number of Requests

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). For example, if the ith server is busy, try to assign the request to the (i+1)th server, then the (i+2)th server, and so on.

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.

Example 1:

Input: k = 3, arrival = [1,2,3,4,5], load = [5,2,3,3,3]
Output: [1]
Explanation:
All of the servers start out available.
The first 3 requests are handled by the first 3 servers in order.
Request 3 comes in. Server 0 is busy, so it’s assigned to the next available server, which is 1.
Request 4 comes in. It cannot be handled since all servers are busy, so it is dropped.
Servers 0 and 2 handled one request each, while server 1 handled two requests. Hence server 1 is the busiest server.

Example 2:

Input: k = 3, arrival = [1,2,3,4], load = [1,2,1,2]
Output: [0]
Explanation:
The first 3 requests are handled by first 3 servers.
Request 3 comes in. It is handled by server 0 since the server is available.
Server 0 handled two requests, while servers 1 and 2 handled one request each. Hence server 0 is the busiest server.

Example 3:

Input: k = 3, arrival = [1,2,3], load = [10,12,11]
Output: [0,1,2]
Explanation: Each server handles a single request, so they are all considered the busiest.

Constraints:

1 <= k <= 105
1 <= arrival.length, load.length <= 105
arrival.length == load.length
1 <= arrival[i], load[i] <= 109
arrival is strictly increasing.

Complexity Analysis

Time Complexity: O(n\log n)
Space Complexity: O(n)

1606. Find Servers That Handled Most Number of Requests LeetCode Solution in C++

class Solution {
 public:
  vector<int> busiestServers(int k, vector<int>& arrival, vector<int>& load) {
    vector<int> ans;
    vector<int> times(k);
    set<int> idleServers;
    // (endTime, server)
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> minHeap;

    for (int i = 0; i < k; ++i)
      idleServers.insert(i);

    for (int i = 0; i < arrival.size(); ++i) {
      // Pop all the servers that are available now.
      while (!minHeap.empty() && minHeap.top().first <= arrival[i]) {
        idleServers.insert(minHeap.top().second);
        minHeap.pop();
      }
      // Get the next available server.
      const int server = getNextAvailableServer(idleServers, i, k);
      if (server == -1)
        continue;
      ++times[server];
      minHeap.emplace(arrival[i] + load[i], server);
      idleServers.erase(server);
    }

    const int busiest = ranges::max(times);
    for (int i = 0; i < k; ++i)
      if (times[i] == busiest)
        ans.push_back(i);
    return ans;
  }

 private:
  int getNextAvailableServer(const set<int>& idleServers, int ithRequest,
                             int k) {
    if (idleServers.empty())
      return -1;
    const auto it = idleServers.lower_bound(ithRequest % k);
    return it == idleServers.cend() ? *idleServers.begin() : *it;
  }
};
/* code provided by PROGIEZ */

1606. Find Servers That Handled Most Number of Requests LeetCode Solution in Java

class Solution {
  public List<Integer> busiestServers(int k, int[] arrival, int[] load) {
    List<Integer> ans = new ArrayList<>();
    int[] times = new int[k];
    TreeSet<Integer> idleServers = new TreeSet<>();
    // (endTime, server)
    Queue<Pair<Integer, Integer>> minHeap = new PriorityQueue<>(Comparator.comparing(Pair::getKey));

    for (int i = 0; i < k; ++i)
      idleServers.add(i);

    for (int i = 0; i < arrival.length; ++i) {
      // Pop all the servers that are available now.
      while (!minHeap.isEmpty() && minHeap.peek().getKey() <= arrival[i]) {
        idleServers.add(minHeap.peek().getValue());
        minHeap.poll();
      }
      // Get the next available server.
      final int server = getNextAvailableServer(idleServers, i, k);
      if (server == -1)
        continue;
      ++times[server];
      minHeap.offer(new Pair<>(arrival[i] + load[i], server));
      idleServers.remove(server);
    }

    final int busiest = Arrays.stream(times).max().getAsInt();
    for (int i = 0; i < k; ++i)
      if (times[i] == busiest)
        ans.add(i);
    return ans;
  }

  private int getNextAvailableServer(TreeSet<Integer> idleServers, int ithRequest, int k) {
    if (idleServers.isEmpty())
      return -1;
    Integer server = idleServers.ceiling(ithRequest % k);
    return server == null ? idleServers.first() : server;
  }
}
// code provided by PROGIEZ

1606. Find Servers That Handled Most Number of Requests LeetCode Solution in Python

N/A
 # code by PROGIEZ

Additional Resources

Happy Coding! Keep following PROGIEZ for more updates and solutions.

Table of Contents