Find Minimum Time to Finish All Jobs II - Problem

You are given two 0-indexed integer arrays jobs and workers of equal length, where jobs[i] is the amount of time needed to complete the i-th job, and workers[j] is the amount of time the j-th worker can work each day.

Each job should be assigned to exactly one worker, such that each worker completes exactly one job.

Return the minimum number of days needed to complete all the jobs after assignment.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Each worker can work 1 hour per day. Jobs take 3, 2, and 3 hours respectively. The workers need ceil(3/1)=3, ceil(2/1)=2, and ceil(3/1)=3 days. Maximum is 3 days.

Example 2 — Optimal Assignment

$ Input: jobs = [1,2,4,7,8], workers = [2,4,1,4,7]

› Output: 2

💡 Note: Optimal assignment: job 8→worker 7 (2 days), job 7→worker 4 (2 days), job 4→worker 4 (1 day), job 2→worker 2 (1 day), job 1→worker 1 (1 day). Maximum is 2 days.

Example 3 — Equal Capacity

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

› Output: 1

💡 Note: Each worker can complete their assigned job in exactly 1 day since job time equals worker capacity.

Constraints

1 ≤ jobs.length == workers.length ≤ 12
1 ≤ jobs[i], workers[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Facebook 12

The key insight is that we want to minimize the maximum days needed across all workers. The optimal solution uses binary search on the answer to find the minimum feasible days, checking each candidate by greedily assigning jobs to workers. Time: O(n² log(max(jobs))), Space: O(1)

Common Approaches

✓ Sliding Window

⏱️ Time: N/A Space: N/A

Brute Force - Try All Permutations

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

Try every possible way to assign jobs to workers. For each assignment, calculate how many days each worker needs (job_time / worker_capacity rounded up), then take the maximum across all workers.

Greedy - Sort and Match Optimally

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

The key insight is that we want to minimize the maximum days needed. Sort jobs in descending order (hardest first) and workers in ascending order (weakest first), then pair the hardest job with the strongest available worker to minimize bottlenecks.

Optimal - Binary Search on Answer

⏱️ Time: O(n² log(max(jobs))) Space: O(1)

Binary search on the answer space (minimum possible days). For each candidate number of days, use a greedy approach to check if it's possible to assign all jobs such that no worker exceeds that many days.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int min_max_days;

int* parse_array(char* str, int* size) {
    *size = 0;
    if (strlen(str) <= 2) {
        return NULL;
    }
    
    // Count commas to determine array size
    int count = 1;
    for (int i = 1; i < strlen(str) - 1; i++) {
        if (str[i] == ',') count++;
    }
    
    int* result = malloc(count * sizeof(int));
    *size = count;
    
    // Parse numbers
    char* inner = malloc(strlen(str));
    strncpy(inner, str + 1, strlen(str) - 2);
    inner[strlen(str) - 2] = '\0';
    
    char* token = strtok(inner, ",");
    int i = 0;
    while (token != NULL && i < count) {
        result[i] = atoi(token);
        token = strtok(NULL, ",");
        i++;
    }
    
    free(inner);
    return result;
}

void permute(int* arr, int start, int len, int* jobs, int n) {
    if (start == len - 1) {
        // Calculate max days for this assignment
        int max_days = 0;
        for (int i = 0; i < n; i++) {
            int days = (jobs[i] + arr[i] - 1) / arr[i]; // Ceiling division
            if (days > max_days) {
                max_days = days;
            }
        }
        if (max_days < min_max_days) {
            min_max_days = max_days;
        }
        return;
    }
    
    for (int i = start; i < len; i++) {
        // Swap
        int temp = arr[start];
        arr[start] = arr[i];
        arr[i] = temp;
        
        permute(arr, start + 1, len, jobs, n);
        
        // Swap back
        temp = arr[start];
        arr[start] = arr[i];
        arr[i] = temp;
    }
}

int min_days_to_complete_jobs(int* jobs, int jobs_size, int* workers, int workers_size) {
    min_max_days = INT_MAX;
    
    // Create copy of workers array
    int* workers_copy = malloc(workers_size * sizeof(int));
    for (int i = 0; i < workers_size; i++) {
        workers_copy[i] = workers[i];
    }
    
    permute(workers_copy, 0, workers_size, jobs, jobs_size);
    
    free(workers_copy);
    return min_max_days;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int jobs_size, workers_size;
    int* jobs = parse_array(line1, &jobs_size);
    int* workers = parse_array(line2, &workers_size);
    
    int result = min_days_to_complete_jobs(jobs, jobs_size, workers, workers_size);
    printf("%d\n", result);
    
    free(jobs);
    free(workers);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~25 min Avg. Time

485 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