Find Minimum Time to Finish All Jobs II - Practice Coding Problems

Find Minimum Time to Finish All Jobs II - Problem

You are given two 0-indexed integer arrays jobs and workers of equal length, representing a perfect job assignment scenario.

The Problem: You need to assign each job to exactly one worker such that:

jobs[i] represents the time needed to complete the i-th job
workers[j] represents the daily working capacity of the j-th worker
Each job must be assigned to exactly one worker
Each worker gets exactly one job

Goal: Find the minimum number of days needed to complete all jobs after optimal assignment.

Example: If we have jobs [3, 2, 3] and workers [1, 2, 3], the optimal assignment pairs the longest job with the most capable worker to minimize the maximum completion time.

Input & Output

example_1.py — Basic Assignment

$ Input: jobs = [3, 2, 3], workers = [1, 2, 3]

› Output: 2

💡 Note: Optimal assignment: Job[3,3,2] → Worker[3,2,1] gives max(1,2,2) = 2 days

example_2.py — Equal Capacity

$ Input: jobs = [1, 1], workers = [1, 1]

› Output: 1

💡 Note: All jobs take 1 day regardless of assignment, so minimum is 1 day

example_3.py — Large Job Difference

$ Input: jobs = [5, 1], workers = [1, 5]

› Output: 1

💡 Note: Assign job 5 to worker 5 (1 day) and job 1 to worker 1 (1 day) = 1 day total

Visualization

Tap to expand

Understanding the Visualization

List All Orders

We have dishes of varying complexity and chefs with different skill levels

Strategic Assignment

Assign the most complex dishes to the most skilled chefs

Minimize Wait Time

The slowest chef determines when all dishes are ready

Key Takeaway

🎯 Key Insight: The greedy strategy of pairing the most demanding jobs with the most capable workers minimizes the bottleneck, ensuring optimal completion time.

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to evaluate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation and tracking minimum

⚡ Linearithmic Space

Constraints

1 ≤ jobs.length ≤ 1000
jobs.length == workers.length
1 ≤ jobs[i], workers[i] ≤ 10⁴
Each job must be assigned to exactly one worker
Each worker gets exactly one job

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a greedy approach with sorting. Sort both arrays in descending order and pair the largest job with the most capable worker. This minimizes the bottleneck (maximum completion time) achieving O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Permutations)	O(n! × n)	O(n)	Try all possible job-to-worker assignments and find the minimum days
Greedy with Sorting (Optimal)	O(n log n)	O(n)	Sort both arrays and pair largest jobs with most capable workers

Brute Force (All Permutations) — Algorithm Steps

Generate all n! permutations of job assignments
For each permutation, calculate days needed as max(jobs[i] / workers[perm[i]])
Track the minimum days across all permutations
Return the minimum days found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible ways to assign jobs to workers

Calculate Days

For each assignment, find the maximum days needed

Track Minimum

Keep track of the best assignment found so far

Code -

solution.c — C

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

int minDays = INT_MAX;

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

void permute(int* jobs, int* workers, int* indices, int start, int n) {
    if (start == n) {
        int maxDays = 0;
        for (int i = 0; i < n; i++) {
            int daysNeeded = (jobs[i] + workers[indices[i]] - 1) / workers[indices[i]];
            if (daysNeeded > maxDays) maxDays = daysNeeded;
        }
        if (maxDays < minDays) minDays = maxDays;
        return;
    }
    
    for (int i = start; i < n; i++) {
        swap(&indices[start], &indices[i]);
        permute(jobs, workers, indices, start + 1, n);
        swap(&indices[start], &indices[i]);
    }
}

int jobScheduling(int* jobs, int* workers, int n) {
    int* indices = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) indices[i] = i;
    
    minDays = INT_MAX;
    permute(jobs, workers, indices, 0, n);
    
    free(indices);
    return minDays;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to evaluate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation and tracking minimum

⚡ Linearithmic Space

Constraints

1 ≤ jobs.length ≤ 1000
jobs.length == workers.length
1 ≤ jobs[i], workers[i] ≤ 10⁴
Each job must be assigned to exactly one worker
Each worker gets exactly one job

52.3K Views

Medium Frequency

~15 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler