Find Servers That Handled Most Number of Requests

Find Servers That Handled Most Number of Requests - Problem

Load Balancer Challenge: You're managing a server farm with k servers numbered from 0 to k-1. Each server can handle only one request at a time but has infinite computational capacity.

When the i-th request arrives, your load balancer follows these rules:
1. If all servers are busy → drop the request
2. If server (i % k) is available → assign to that server
3. Otherwise → find the next available server in circular order

Given arrays arrival (request arrival times) and load (processing durations), find which server(s) handled the most requests.

Example: With 3 servers and requests arriving at times [1,2,3,4] with loads [5,2,3,3], server assignment follows the circular pattern while respecting busy periods.

Input & Output

example_1.py — Basic Load Balancing

$ Input: k = 3, arrival = [1,2,3,4,5], load = [5,2,3,3,3]

› Output: [0,1,2]

💡 Note: Request 0 (arrival=1, load=5) → server 0 (preferred 0%3=0, available). Request 1 (arrival=2, load=2) → server 1 (preferred 1%3=1, available). Request 2 (arrival=3, load=3) → server 2 (preferred 2%3=2, available). Request 3 (arrival=4, load=3) → server 0 (preferred 3%3=0, but busy until time 6, so check server 1 busy until 4, so check server 2 busy until 6, so assign to server 1). Request 4 (arrival=5, load=3) → server 2. All servers handled 2 requests each.

example_2.py — Servers Get Busy

$ Input: k = 3, arrival = [1,2,3,4], load = [1,2,3,4]

› Output: [0]

💡 Note: Request 0 → server 0 (free at time 2). Request 1 → server 1 (free at time 4). Request 2 → server 2 (free at time 6). Request 3 → server 0 (preferred server 0 is free at time 2, current time is 4). Server 0 handles 2 requests, others handle 1 each.

example_3.py — All Servers Busy

$ Input: k = 2, arrival = [1,2,3], load = [10,12,11]

› Output: [0,1]

💡 Note: Request 0 → server 0 (busy until time 11). Request 1 → server 1 (busy until time 14). Request 2 at time 3 → all servers busy (0 until 11, 1 until 14), so request is dropped. Both servers handled 1 request each.

Constraints

1 ≤ k ≤ 10⁵
1 ≤ arrival.length, load.length ≤ 10⁵
arrival.length == load.length
1 ≤ arrival[i], load[i] ≤ 10⁹
arrival is strictly increasing

Visualization

Tap to expand

Understanding the Visualization

Request Arrives

New request arrives at specified time with given processing duration

Check Preferred Server

Calculate preferred server as request_index % k and check if available

Find Next Available

If preferred server busy, search circularly for next available server

Assign or Drop

Assign to found server or drop if all servers are busy

Update State

Update server's free time and increment its request counter

Key Takeaway

🎯 Key Insight: Use efficient data structures (min-heap + ordered set) to avoid O(k) linear searches, reducing complexity from O(n×k) to O(n×log k)

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a min-heap to track when servers become free and an ordered set to efficiently find the next available server. This achieves O(n log k) time complexity by avoiding linear searches through all servers for each request.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Simulation with Priority Queue	O(n log k)	O(k)	Use min-heap to track server free times and ordered set for efficient server lookup

Optimized Simulation with Priority Queue — Algorithm Steps

Use min-heap to track (free_time, server_id) pairs
Use ordered set to maintain available servers
For each request, free up servers whose free_time <= arrival_time
Find next available server >= preferred server using ordered set
If no server found, wrap around and find from server 0
Update data structures and increment request count

Visualization

Tap to expand

Step-by-Step Walkthrough

Free Busy Servers

Use min-heap to automatically free servers when their free time is reached

Find Available Server

Use ordered set to quickly find next available server >= preferred

Update Structures

Remove from available set, add to busy heap with new free time

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct {
    int freeTime;
    int id;
} Server;

// Simple heap implementation
void heapify(Server* heap, int n, int i) {
    int smallest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    
    if (left < n && heap[left].freeTime < heap[smallest].freeTime)
        smallest = left;
    if (right < n && heap[right].freeTime < heap[smallest].freeTime)
        smallest = right;
    
    if (smallest != i) {
        Server temp = heap[i];
        heap[i] = heap[smallest];
        heap[smallest] = temp;
        heapify(heap, n, smallest);
    }
}

int* busiestServers(int k, int* arrival, int arrivalSize, int* load, int loadSize, int* returnSize) {
    Server* busyHeap = (Server*)malloc(arrivalSize * sizeof(Server));
    int heapSize = 0;
    bool* available = (bool*)malloc(k * sizeof(bool));
    int* requestCount = (int*)calloc(k, sizeof(int));
    
    for (int i = 0; i < k; i++) available[i] = true;
    
    for (int i = 0; i < arrivalSize; i++) {
        // Free servers (simplified)
        int newHeapSize = 0;
        for (int j = 0; j < heapSize; j++) {
            if (busyHeap[j].freeTime <= arrival[i]) {
                available[busyHeap[j].id] = true;
            } else {
                busyHeap[newHeapSize++] = busyHeap[j];
            }
        }
        heapSize = newHeapSize;
        
        int preferred = i % k;
        int server = -1;
        
        for (int j = 0; j < k; j++) {
            int candidate = (preferred + j) % k;
            if (available[candidate]) {
                server = candidate;
                break;
            }
        }
        
        if (server != -1) {
            available[server] = false;
            busyHeap[heapSize].freeTime = arrival[i] + load[i];
            busyHeap[heapSize].id = server;
            heapSize++;
            requestCount[server]++;
        }
    }
    
    int maxRequests = 0;
    for (int i = 0; i < k; i++) {
        if (requestCount[i] > maxRequests) {
            maxRequests = requestCount[i];
        }
    }
    
    int* result = (int*)malloc(k * sizeof(int));
    *returnSize = 0;
    for (int i = 0; i < k; i++) {
        if (requestCount[i] == maxRequests) {
            result[(*returnSize)++] = i;
        }
    }
    
    free(busyHeap);
    free(available);
    free(requestCount);
    return result;
}

int main() {
    int arrival[] = {1, 2, 3, 4, 5};
    int load[] = {5, 2, 3, 3, 3};
    int returnSize;
    int* result = busiestServers(3, arrival, 5, load, 5, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

Each request processes at most k servers with log k operations for heap and ordered set

⚡ Linearithmic

Space Complexity

O(k)

Priority queue and ordered set store at most k servers

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimized Simulation with Priority Queue — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler