Minimum Processing Time

Minimum Processing Time - Problem

You have a certain number of processors, each having 4 cores. The number of tasks to be executed is four times the number of processors. Each task must be assigned to a unique core, and each core can only be used once.

You are given an array processorTime representing the time each processor becomes available and an array tasks representing how long each task takes to complete.

Return the minimum time needed to complete all tasks.

Input & Output

Example 1 — Basic Case

$ Input: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]

› Output: 26

💡 Note: Sort processors: [8,10]. Sort tasks: [8,7,5,4,3,2,2,1]. Assign tasks[0,2,4,6] = [8,5,3,2] to processor 0 (completion: 8+18=26) and tasks[1,3,5,7] = [7,4,2,1] to processor 1 (completion: 10+14=24). Maximum completion time is 26.

Example 2 — Equal Processors

$ Input: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]

› Output: 31

💡 Note: Sort processors: [10,20]. Sort tasks: [8,5,4,3,3,2,2,1]. Assign tasks[0,2,4,6] = [8,4,3,2] to processor 0 (completion: 10+17=27) and tasks[1,3,5,7] = [5,3,2,1] to processor 1 (completion: 20+11=31). Maximum completion time is 31.

Example 3 — Single Processor

$ Input: processorTime = [0], tasks = [1,2,3,4]

› Output: 10

💡 Note: One processor gets all 4 tasks: 0 + (1+2+3+4) = 10

Constraints

1 ≤ n ≤ 10⁴ (where n is number of processors)
tasks.length == 4 * n
1 ≤ processorTime[i] ≤ 10⁹
1 ≤ tasks[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 23 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is to assign the heaviest tasks to processors that become available earliest. Sort tasks in descending order and processors in ascending order, then assign tasks greedily. Best approach is greedy assignment with Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Assignments

⏱️ Time: O(n!) Space: O(n)

Try every possible way to assign tasks to processor cores. For each assignment, calculate when all tasks complete and track the minimum time across all possibilities.

Greedy - Sort and Assign Optimally

⏱️ Time: O(n log n) Space: O(1)

Sort tasks in descending order and processors in ascending order. Assign the heaviest tasks to the processors that become available earliest to minimize maximum completion time.

Brute Force - Try All Assignments — Algorithm Steps

Generate all permutations of task assignments
For each assignment, calculate completion time
Track minimum time across all assignments

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible orderings of tasks

Assign to Processors

For each permutation, assign 4 tasks per processor

Find Minimum

Track the assignment with minimum completion time

Code -

solution.c — C

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

static int processorTime[100];
static int tasks[400];
static int sortedProcessors[100];
static int completionTimes[100];

int compare_desc(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

int compare_processors(const void *a, const void *b) {
    int idxA = *(int*)a;
    int idxB = *(int*)b;
    return processorTime[idxA] - processorTime[idxB];
}

int solution(int procLen, int taskLen) {
    int n = procLen;
    
    // Sort processors by availability time (ascending)
    for (int i = 0; i < n; i++) {
        sortedProcessors[i] = i;
    }
    qsort(sortedProcessors, n, sizeof(int), compare_processors);
    
    // Sort tasks by duration (descending)
    qsort(tasks, taskLen, sizeof(int), compare_desc);
    
    // Initialize completion times for each processor
    for (int i = 0; i < n; i++) {
        completionTimes[i] = processorTime[i];
    }
    
    // Assign 4 tasks at a time to each processor in order
    for (int i = 0; i < n; i++) {
        int processorIdx = sortedProcessors[i];
        // Assign 4 tasks to this processor (tasks i*4 to i*4+3)
        for (int j = 0; j < 4; j++) {
            int taskIdx = i * 4 + j;
            if (taskIdx < taskLen) {
                completionTimes[processorIdx] += tasks[taskIdx];
            }
        }
    }
    
    // Return maximum completion time
    int max = completionTimes[0];
    for (int i = 1; i < n; i++) {
        if (completionTimes[i] > max) {
            max = completionTimes[i];
        }
    }
    return max;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    int procLen = 0, taskLen = 0;
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    parseArray(line, processorTime, &procLen);
    
    fgets(line, sizeof(line), stdin);
    parseArray(line, tasks, &taskLen);
    
    printf("%d\n", solution(procLen, taskLen));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

Generates all n! permutations of task assignments

⚡ Linearithmic

Space Complexity

O(n)

Recursion stack for generating permutations

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

856 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

Brute Force - Try All Assignments — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler