Minimum Difficulty of a Job Schedule

Minimum Difficulty of a Job Schedule - Problem

You want to schedule a list of jobs in d days. Jobs are dependent (i.e., to work on the i-th job, you have to finish all jobs j where 0 <= j < i).

You have to finish at least one task every day. The difficulty of a job schedule is the sum of difficulties of each day of the d days. The difficulty of a day is the maximum difficulty of a job done on that day.

Given an integer array jobDifficulty and an integer d, return the minimum difficulty of a job schedule. If you cannot find a schedule for the jobs, return -1.

Input & Output

Example 1 — Basic Case

$ Input: jobDifficulty = [6,5,4,3,2,1], d = 2

› Output: 7

💡 Note: Optimal schedule: Day 1 = [6,5,4,3,2] (max=6), Day 2 = [1] (max=1). Total difficulty = 6 + 1 = 7.

Example 2 — Single Day

$ Input: jobDifficulty = [9,9,9], d = 1

› Output: 9

💡 Note: All jobs must be done in 1 day. The difficulty is the maximum job difficulty = 9.

Example 3 — Impossible Case

$ Input: jobDifficulty = [1,1,1], d = 4

› Output: -1

💡 Note: Cannot schedule 3 jobs across 4 days since each day needs at least one job.

Constraints

1 ≤ jobDifficulty.length ≤ 300
0 ≤ jobDifficulty[i] ≤ 1000
1 ≤ d ≤ 10

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to use dynamic programming to find the minimum sum of daily maximum difficulties. We can solve this with memoized recursion or bottom-up DP. Best approach is 2D DP with Time: O(n²×d), Space: O(n×d).

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(n² × d) Space: O(n × d)

Create a 2D table dp[i][j] representing minimum difficulty to schedule first i jobs in j days. Fill table bottom-up by considering all ways to end each day.

Brute Force Recursion

⏱️ Time: O(d^n) Space: O(n)

For each position, try assigning remaining jobs to remaining days. Use recursion to explore all valid partitions where each day gets at least one job.

Memoization (Top-Down DP)

⏱️ Time: O(n² × d) Space: O(n × d)

Same recursive approach as brute force but store results in a memo table indexed by (day, start_position) to avoid redundant calculations.

Bottom-Up Dynamic Programming — Algorithm Steps

Initialize base cases for 1 day
For each day and job count, try all possible last day endings
Return dp[n][d] as final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set base cases and table boundaries

Fill Table

For each cell, try all possible day endings

Result

Return dp[n][d] as minimum difficulty

Code -

solution.c — C

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

int solution(int* jobDifficulty, int n, int d) {
    if (n < d) return -1;
    
    // Dynamically allocate dp array
    int** dp = (int**)malloc((n + 1) * sizeof(int*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (int*)malloc((d + 1) * sizeof(int));
    }
    
    // Initialize dp array
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= d; j++) {
            dp[i][j] = INT_MAX;
        }
    }
    dp[0][0] = 0;
    
    for (int i = 1; i <= n; i++) {
        int maxDays = (i < d) ? i : d;
        for (int j = 1; j <= maxDays; j++) {
            // Try all possible ways to end day j
            int maxDifficulty = 0;
            for (int k = i; k >= j; k--) {
                if (jobDifficulty[k - 1] > maxDifficulty) {
                    maxDifficulty = jobDifficulty[k - 1];
                }
                if (dp[k - 1][j - 1] != INT_MAX) {
                    int candidate = dp[k - 1][j - 1] + maxDifficulty;
                    if (candidate < dp[i][j]) {
                        dp[i][j] = candidate;
                    }
                }
            }
        }
    }
    
    int result = dp[n][d] == INT_MAX ? -1 : dp[n][d];
    
    // Free allocated memory
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int jobDifficulty[100];
    int n = 0;
    
    // Parse array format [a,b,c,d]
    char* p = line;
    while (*p && *p != '[') p++;  // Find opening bracket
    if (*p == '[') p++;  // Skip opening bracket
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number
        jobDifficulty[n++] = (int)strtol(p, &p, 10);
    }
    
    int d;
    scanf("%d", &d);
    
    printf("%d\n", solution(jobDifficulty, n, d));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × d)

Triple nested loops: d days × n jobs × n possible endings

⚠ Quadratic Growth

Space Complexity

O(n × d)

2D DP table with n×d entries

⚡ Linearithmic Space

85.0K Views

Medium Frequency

~35 min Avg. Time

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

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler