Process Tasks Using Servers - Practice Coding Problems

Process Tasks Using Servers - Problem

Imagine you're managing a data center where multiple servers need to process incoming tasks efficiently. You have n servers with different processing capabilities (weights) and m tasks that arrive sequentially over time.

The Challenge: You need to assign each task to the most suitable available server following these rules:

🕐 Task j arrives at second j and joins a queue
⚖️ Always assign tasks to the lightest available server (smallest weight)
🔢 If weights are equal, choose the server with the smallest index
⏳ A server processing a task becomes unavailable for tasks[j] seconds
🚫 If no servers are free, tasks wait in queue until one becomes available

Goal: Return an array where ans[j] is the index of the server that processes task j.

Input: Two arrays - servers[i] (server weights) and tasks[j] (task durations)

Output: Array of server indices showing which server processes each task

Input & Output

example_1.py — Basic Assignment

$ Input: servers = [3,3,2], tasks = [1,2,3,2,1,2]

› Output: [2,2,0,2,1,2]

💡 Note: Tasks arrive at seconds 0,1,2,3,4,5. Server 2 (weight=2) is lightest and handles most tasks. When busy, tasks wait or use other servers based on availability and weight.

example_2.py — All Servers Busy

$ Input: servers = [5,1,4,3,2], tasks = [2,1,2,4,5,2,1]

› Output: [1,4,1,4,1,3,2]

💡 Note: Server 1 (weight=1) is preferred but becomes busy. Tasks are assigned to next best available servers or wait for preferred servers to become free.

example_3.py — Single Server

$ Input: servers = [10], tasks = [1,1,1,1]

› Output: [0,0,0,0]

💡 Note: Only one server available, so all tasks must be assigned to server 0, with tasks queuing when the server is busy.

Constraints

n == servers.length
m == tasks.length
1 ≤ n, m ≤ 2 × 10⁵
1 ≤ servers[i], tasks[j] ≤ 2 × 10⁵
All server weights and task durations are positive integers

Visualization

Tap to expand

Understanding the Visualization

Tasks Arrive

Tasks enter the system at regular intervals and join a processing queue

Find Best Server

System identifies the lightest available server (or waits for one to become free)

Assign & Process

Task is assigned to the selected server and begins processing

Update Status

Server status is updated and will become available again after task completion

Key Takeaway

🎯 Key Insight: Use two priority heaps to efficiently manage server availability and selection, achieving optimal O((m+n) × log n) performance

Asked in

a Amazon 28 G Google 15 ⊞ Microsoft 12 f Meta 8

The optimal solution uses two priority heaps: one for available servers (sorted by weight, then index) and another for busy servers (sorted by completion time). This achieves O((m+n) × log n) time complexity by efficiently managing server assignments and availability transitions.

Common Approaches

Approach	Time	Space	Notes
✓ Priority Heaps (Optimal)	O((m + n) × log n)	O(n)	Use two priority heaps to efficiently manage server assignments
Brute Force (Linear Search)	O(m × n)	O(1)	For each task, linearly search for the best available server

Priority Heaps (Optimal) — Algorithm Steps

Initialize available heap with all servers (weight, index)
Initialize busy heap for servers currently processing tasks
For each task, advance time and move freed servers to available heap
If available servers exist, assign to the best one (heap top)
Otherwise, wait for earliest server to finish and assign
Update server status and heaps accordingly

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Heaps

Available heap sorted by weight/index, busy heap sorted by finish time

Process Task

Move finished servers from busy to available heap

Assign Best Server

Pop minimum server from available heap

Update Status

Push server to busy heap with completion time

Code -

solution.c — C

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

typedef struct {
    int weight;
    int index;
} Server;

typedef struct {
    long long finishTime;
    int weight;
    int index;
} BusyServer;

// Simple heap implementation for available servers
typedef struct {
    Server* arr;
    int size;
    int capacity;
} ServerHeap;

// Simple heap implementation for busy servers
typedef struct {
    BusyServer* arr;
    int size;
    int capacity;
} BusyHeap;

ServerHeap* createServerHeap(int capacity) {
    ServerHeap* heap = (ServerHeap*)malloc(sizeof(ServerHeap));
    heap->arr = (Server*)malloc(sizeof(Server) * capacity);
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

BusyHeap* createBusyHeap(int capacity) {
    BusyHeap* heap = (BusyHeap*)malloc(sizeof(BusyHeap));
    heap->arr = (BusyServer*)malloc(sizeof(BusyServer) * capacity);
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void serverHeapify(ServerHeap* heap, int i) {
    int smallest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    
    if (left < heap->size) {
        if (heap->arr[left].weight < heap->arr[smallest].weight ||
            (heap->arr[left].weight == heap->arr[smallest].weight && 
             heap->arr[left].index < heap->arr[smallest].index)) {
            smallest = left;
        }
    }
    
    if (right < heap->size) {
        if (heap->arr[right].weight < heap->arr[smallest].weight ||
            (heap->arr[right].weight == heap->arr[smallest].weight && 
             heap->arr[right].index < heap->arr[smallest].index)) {
            smallest = right;
        }
    }
    
    if (smallest != i) {
        Server temp = heap->arr[i];
        heap->arr[i] = heap->arr[smallest];
        heap->arr[smallest] = temp;
        serverHeapify(heap, smallest);
    }
}

void busyHeapify(BusyHeap* heap, int i) {
    int smallest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    
    if (left < heap->size && heap->arr[left].finishTime < heap->arr[smallest].finishTime) {
        smallest = left;
    }
    
    if (right < heap->size && heap->arr[right].finishTime < heap->arr[smallest].finishTime) {
        smallest = right;
    }
    
    if (smallest != i) {
        BusyServer temp = heap->arr[i];
        heap->arr[i] = heap->arr[smallest];
        heap->arr[smallest] = temp;
        busyHeapify(heap, smallest);
    }
}

Server extractMinServer(ServerHeap* heap) {
    Server min = heap->arr[0];
    heap->arr[0] = heap->arr[heap->size - 1];
    heap->size--;
    serverHeapify(heap, 0);
    return min;
}

BusyServer extractMinBusy(BusyHeap* heap) {
    BusyServer min = heap->arr[0];
    heap->arr[0] = heap->arr[heap->size - 1];
    heap->size--;
    busyHeapify(heap, 0);
    return min;
}

void insertServer(ServerHeap* heap, Server server) {
    heap->arr[heap->size] = server;
    int i = heap->size;
    heap->size++;
    
    while (i > 0) {
        int parent = (i - 1) / 2;
        if (heap->arr[i].weight < heap->arr[parent].weight ||
            (heap->arr[i].weight == heap->arr[parent].weight && 
             heap->arr[i].index < heap->arr[parent].index)) {
            Server temp = heap->arr[i];
            heap->arr[i] = heap->arr[parent];
            heap->arr[parent] = temp;
            i = parent;
        } else {
            break;
        }
    }
}

void insertBusy(BusyHeap* heap, BusyServer server) {
    heap->arr[heap->size] = server;
    int i = heap->size;
    heap->size++;
    
    while (i > 0) {
        int parent = (i - 1) / 2;
        if (heap->arr[i].finishTime < heap->arr[parent].finishTime) {
            BusyServer temp = heap->arr[i];
            heap->arr[i] = heap->arr[parent];
            heap->arr[parent] = temp;
            i = parent;
        } else {
            break;
        }
    }
}

int* assignTasks(int* servers, int serversSize, int* tasks, int tasksSize, int* returnSize) {
    ServerHeap* available = createServerHeap(serversSize);
    BusyHeap* busy = createBusyHeap(serversSize);
    
    // Initialize available servers
    for (int i = 0; i < serversSize; i++) {
        Server s = {servers[i], i};
        insertServer(available, s);
    }
    
    int* result = (int*)malloc(tasksSize * sizeof(int));
    *returnSize = tasksSize;
    
    for (int taskIdx = 0; taskIdx < tasksSize; taskIdx++) {
        long long currentTime = taskIdx;
        int taskDuration = tasks[taskIdx];
        
        // Move finished servers back to available
        while (busy->size > 0 && busy->arr[0].finishTime <= currentTime) {
            BusyServer bs = extractMinBusy(busy);
            Server s = {bs.weight, bs.index};
            insertServer(available, s);
        }
        
        // If no servers available, wait for earliest
        if (available->size == 0) {
            BusyServer bs = extractMinBusy(busy);
            currentTime = bs.finishTime;
            Server s = {bs.weight, bs.index};
            insertServer(available, s);
        }
        
        // Assign task to best available server
        Server s = extractMinServer(available);
        result[taskIdx] = s.index;
        
        // Move server to busy
        BusyServer bs = {currentTime + taskDuration, s.weight, s.index};
        insertBusy(busy, bs);
    }
    
    free(available->arr);
    free(available);
    free(busy->arr);
    free(busy);
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((m + n) × log n)

Each task requires O(log n) heap operations, with potential server transitions

⚡ Linearithmic

Space Complexity

O(n)

Two heaps store at most n servers total

⚡ Linearithmic Space

31.8K Views

High Frequency

~25 min Avg. Time

1.4K 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

Priority Heaps (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler