Minimum Processing Time - Practice Coding Problems

Minimum Processing Time - Problem

Minimum Processing Time is a fascinating optimization problem that simulates real-world task scheduling scenarios.

You're managing a data center with n processors, where each processor has exactly 4 cores. You have 4n tasks to execute (exactly 4 times the number of processors), and each task must be assigned to a unique core - no core can handle multiple tasks.

You're given two arrays:
• processorTime: When each processor becomes available (length n)
• tasks: How long each task takes to complete (length 4n)

Your goal is to assign tasks to cores such that the maximum completion time across all processors is minimized. Each processor's completion time is determined by its availability time plus the longest task assigned to any of its 4 cores.

Example: If processor becomes available at time 8 and gets tasks [2, 1, 3, 3], its completion time is 8 + max(2,1,3,3) = 8 + 3 = 11.

Input & Output

example_1.py — Basic Case

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

› Output: 16

💡 Note: We have 2 processors and 8 tasks. Optimal assignment: Processor 1 (starts at 8) gets tasks [8,6,4,3] → completion time = 8+8=16. Processor 2 (starts at 10) gets tasks [3,2,2,1] → completion time = 10+3=13. Maximum is 16.

example_2.py — Equal Start Times

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

› Output: 8

💡 Note: All processors start at time 5. With optimal assignment: each processor gets one task of each type [3,2,1,1], so completion time = 5+3=8 for all processors.

example_3.py — Large Time Gaps

$ Input: processorTime = [0, 100], tasks = [10, 10, 10, 10, 1, 1, 1, 1]

› Output: 101

💡 Note: Processor 1 (starts at 0) gets heavy tasks [10,10,10,10] → time = 0+10=10. Processor 2 (starts at 100) gets light tasks [1,1,1,1] → time = 100+1=101. Maximum is 101.

Constraints

1 ≤ n ≤ 10⁴ (number of processors)
tasks.length == 4 * n (exactly 4 tasks per processor)
1 ≤ processorTime[i] ≤ 10⁹
1 ≤ tasks[i] ≤ 10⁹
Each core can only process one task

Visualization

Tap to expand

Understanding the Visualization

Kitchen Setup

Each cooking station has 4 burners and becomes available at different times after cleaning

Dish Queue

You have a queue of dishes with different cooking times - some take much longer than others

Smart Assignment

Give the longest-cooking dishes to stations that are ready earliest

Optimal Service

This strategy minimizes the time when the last dish is served

Key Takeaway

🎯 Key Insight: The greedy approach works because pairing longest tasks with earliest processors creates the most balanced workload distribution, minimizing the maximum completion time.

Asked in

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

The optimal solution uses a greedy approach: sort processors by start time (earliest first) and tasks by duration (longest first). Assign the 4 longest remaining tasks to each processor in order. This ensures that longer tasks are paired with processors that start earlier, minimizing the overall maximum completion time in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Assignments)	O((4n)!/(4!)^n)	O(4n)	Try every possible way to assign tasks to processor cores
Greedy Assignment (Optimal)	O(n log n)	O(1)	Sort processors by start time, sort tasks by duration, assign optimally

Brute Force (Try All Assignments) — Algorithm Steps

Generate all possible ways to divide 4n tasks into n groups of 4
For each assignment, calculate completion time for each processor
Track the minimum maximum completion time across all assignments
Return the optimal assignment's completion time

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutation

Try a different arrangement of tasks

Assign to Processors

Give 4 consecutive tasks to each processor

Calculate Times

Find each processor's completion time

Track Minimum

Keep the best result so far

Code -

solution.c — C

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

int minTime = INT_MAX;

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int max(int a, int b) {
    return a > b ? a : b;
}

int min(int a, int b) {
    return a < b ? a : b;
}

void permute(int* tasks, int start, int size, int* processorTime, int n) {
    if (start == size - 1) {
        int maxCompletion = 0;
        
        for (int i = 0; i < n; i++) {
            int maxTask = 0;
            for (int j = i * 4; j < (i + 1) * 4; j++) {
                maxTask = max(maxTask, tasks[j]);
            }
            int completionTime = processorTime[i] + maxTask;
            maxCompletion = max(maxCompletion, completionTime);
        }
        
        minTime = min(minTime, maxCompletion);
        return;
    }
    
    for (int i = start; i < size; i++) {
        swap(&tasks[start], &tasks[i]);
        permute(tasks, start + 1, size, processorTime, n);
        swap(&tasks[start], &tasks[i]);
    }
}

int minimumTime(int* processorTime, int n, int* tasks, int taskSize) {
    minTime = INT_MAX;
    permute(tasks, 0, taskSize, processorTime, n);
    return minTime;
}

int main() {
    int processorTime[1000], tasks[4000];
    int n = 0, taskSize = 0;
    int num;
    
    while (scanf("%d", &num) == 1) {
        processorTime[n++] = num;
        if (getchar() == '\n') break;
    }
    
    while (scanf("%d", &num) == 1) {
        tasks[taskSize++] = num;
        if (getchar() == '\n' || getchar() == EOF) break;
    }
    
    printf("%d\n", minimumTime(processorTime, n, tasks, taskSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((4n)!/(4!)^n)

We need to try all ways to partition 4n tasks into n groups of 4 tasks each

✓ Linear Growth

Space Complexity

O(4n)

Space to store current assignment and track minimum result

⚡ Linearithmic Space

42.1K Views

High Frequency

~18 min Avg. Time

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