Skip to main content
Talentd

Find Servers That Handled Most Number of Requests - Solution & Explanation

HardArrayGreedyHeap (Priority Queue)Ordered Set12 min readAsked at: Amazon, Apple, Cisco +3
Practice this problem

Problem Statement

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.

Approach Overview

Problem Overview: You have k servers and a sequence of incoming requests with arrival times and processing durations. Each request prefers server i % k. If that server is busy, you assign the request to the next available server in circular order. If all servers are busy, the request is dropped. The task is to return the IDs of servers that handled the highest number of requests.

Approach 1: Brute Force Server Simulation (O(n * k) time, O(k) space)

The simplest strategy directly simulates the scheduling rules. For every request i, start checking from server i % k and scan forward in circular order until you find a free server. Maintain an array tracking when each server becomes available. If the chosen server's next free time is less than or equal to the arrival time, assign the request and update its busy time. Otherwise continue scanning until all servers are checked. This approach mirrors the problem statement exactly but performs up to k checks per request, leading to O(n * k) time complexity. It works only when k is small.

Approach 2: Priority Queue + Ordered Set for Scheduling (O(n log k) time, O(k) space)

The efficient solution treats the problem like a task scheduler. Maintain two data structures: a min-heap tracking busy servers by their finish time and an ordered set storing currently available servers. The heap ensures you quickly release servers whose processing finished before the current request arrives. The ordered set allows you to find the smallest server ID greater than or equal to i % k. If none exists, wrap around and take the smallest server ID in the set.

For each request, first release all servers from the heap whose completion time is ≤ the request arrival. Insert those server IDs back into the available set. Next, search the ordered set for the preferred server using a lower_bound style lookup. If a server is available, assign the request, remove it from the set, and push it into the heap with its new completion time arrival[i] + load[i]. Track the number of handled requests per server and update the maximum.

This greedy scheduling strategy ensures every request is assigned to the closest valid server while maintaining efficient lookups and updates. Heap operations and ordered-set lookups both take O(log k), giving a total complexity of O(n log k). The approach relies heavily on Heap (Priority Queue) operations and an Ordered Set to efficiently find the next server.

Recommended for interviews: The priority queue + ordered set solution is what interviewers expect. It shows you recognize the problem as a scheduling system with resource allocation. Mentioning the brute force simulation first demonstrates understanding of the rules, but implementing the optimized greedy approach using Greedy scheduling and efficient data structures proves strong algorithmic skills.

Approach 1: Using Priority Queue for Scheduled Tasks

This approach involves using a priority queue to manage and track the times when servers become available. Specifically, we will use a heap data structure to efficiently find the first available server for a new request. Whenever a request ends, we reassign the server for future tasks. We also utilize a balanced data structure to cycle through the server indexes and track the server with the most handled requests efficiently.

In this code, a min-heap is used to keep track of busy servers and their availability times. Servers that are free are maintained in another heap. For each arriving request, we check if there are available servers that can handle the request.

The modulo operator is used to determine the target server for each request. If the server is not available, we find the next available server using binary search over the heap structure.

Code

PythonJavaC++JavaScriptC

Python

Java

C++

JavaScript

C

Complexity

Time complexity: O(n log k), where n is the number of requests, due to the heap operations. Space complexity: O(k + n) for the heaps and request count.

Try this approach in the editor →

Approach 2: Default Approach

Code

PythonJavaC++Go

Python

Java

C++

Go

Try this approach in the editor →

Complexity Comparison

ApproachComplexity
Using Priority Queue for Scheduled Tasks

Time complexity: O(n log k), where n is the number of requests, due to the heap operations. Space complexity: O(k + n) for the heaps and request count.

Default Approach—

Detailed Complexity Analysis

ApproachTimeSpaceWhen to Use
Brute Force Server SimulationO(n * k)O(k)Useful for understanding the scheduling rules or when the number of servers is very small.
Priority Queue + Ordered SetO(n log k)O(k)Optimal approach for large inputs. Efficiently tracks busy servers and finds the next available server.

Video Solution

LeetCode 1606. Find Servers That Handled Most Number of Requests • Happy Coding • 3,416 views views

Watch 8 more video solutions →

Frequently Asked Questions

Is Find Servers That Handled Most Number of Requests easy or hard?
The problem is classified as Hard because it combines multiple concepts: circular indexing, greedy scheduling, heap-based task management, and ordered-set lookups. The logic itself is manageable once the correct data structures are chosen, but recognizing that combination during an interview makes it challenging.
Find Servers That Handled Most Number of Requests Python/Java solution
Most implementations use a min-heap to store pairs of (finishTime, serverId) and a balanced ordered structure such as TreeSet in Java or SortedList/TreeSet equivalents in Python. The algorithm processes each request, releases completed servers from the heap, assigns the next available server, and counts handled requests to determine the busiest servers.
How to solve Find Servers That Handled Most Number of Requests in O(n)?
Achieving strict O(n) time is generally not feasible because the algorithm must dynamically locate the next available server and manage busy server completion times. These operations require ordered structures such as a priority queue or balanced tree. The practical optimal complexity is O(n log k) using a heap and ordered set.
What is the best approach for Find Servers That Handled Most Number of Requests?
The most efficient solution uses a greedy scheduling strategy with two data structures: a min-heap (priority queue) for busy servers and an ordered set for available servers. The heap tracks when servers finish processing requests, while the ordered set finds the next valid server starting from i % k. This reduces scheduling operations to O(log k) per request, giving an overall time complexity of O(n log k).
Is Find Servers That Handled Most Number of Requests asked at Google/Amazon/Meta?
This problem represents a classic server scheduling and load balancing scenario commonly discussed in system design and algorithm interviews. Variants of resource scheduling with heaps and ordered sets have appeared in interviews at companies such as Google, Amazon, and Meta, especially for backend or infrastructure roles.
What data structure is used in Find Servers That Handled Most Number of Requests?
The optimal solution relies on two key data structures: a min-heap (priority queue) to track servers currently processing requests and an ordered set to store available server IDs in sorted order. The ordered set enables efficient lower_bound searches to locate the next server starting from i % k.
What is the time complexity of Find Servers That Handled Most Number of Requests?
The optimal solution runs in O(n log k) time, where n is the number of requests and k is the number of servers. Each request may trigger heap operations to release finished servers and ordered-set operations to locate the next available server. Both operations cost O(log k), making the approach scalable for large inputs.

Ready to solve this problem?

Practice Find Servers That Handled Most Number of Requests with our built-in code editor and test cases.

Practice on FleetCode
Previous

Meeting Rooms III