Minimum Difficulty of a Job Schedule - Practice Coding Problems

Minimum Difficulty of a Job Schedule - Problem

You're a project manager who needs to schedule a list of jobs over d days. The jobs have a strict dependency order - you must complete job i before you can start job i+1. Each job has a difficulty rating, and you must complete at least one job each day.

The difficulty of a day is determined by the most challenging job you complete that day. Your goal is to find a schedule that minimizes the total difficulty across all days.

Input: An integer array jobDifficulty where jobDifficulty[i] represents the difficulty of the i-th job, and an integer d representing the number of days available.

Output: Return the minimum total difficulty of the job schedule. If it's impossible to schedule all jobs in d days (i.e., you have more days than jobs), return -1.

Example: Jobs [6,5,4,3,2,1] over 2 days could be split as Day 1: [6,5,4] (difficulty = 6), Day 2: [3,2,1] (difficulty = 3), Total = 9.

Input & Output

example_1.py — Basic Example

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

› Output: 7

💡 Note: One optimal schedule: Day 1 = [6], Day 2 = [5,4,3,2,1]. Day 1 difficulty = 6, Day 2 difficulty = max(5,4,3,2,1) = 5. Total = 6 + 5 = 11. But better schedule: Day 1 = [6,5,4,3,2], Day 2 = [1]. Day 1 difficulty = 6, Day 2 difficulty = 1. Total = 7.

example_2.py — Single Day

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

› Output: -1

💡 Note: We have 3 jobs but need to schedule over 4 days. Since we must do at least one job per day, this is impossible.

example_3.py — Equal Days and Jobs

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

› Output: 3

💡 Note: Each day we do exactly one job. Day 1: [1] (difficulty=1), Day 2: [1] (difficulty=1), Day 3: [1] (difficulty=1). Total = 1+1+1 = 3.

Constraints

1 ≤ jobDifficulty.length ≤ 300
0 ≤ jobDifficulty[i] ≤ 1000
1 ≤ d ≤ 10
The jobs must be completed in the given order
At least one job must be completed each day

Visualization

Tap to expand

Understanding the Visualization

Problem Setup

We have jobs [6,5,4,3,2,1] to schedule over 2 days. Each day's difficulty = max job that day.

Try Different Splits

Day 1: [6] + Day 2: [5,4,3,2,1] gives difficulty 6+5=11. Day 1: [6,5] + Day 2: [4,3,2,1] gives 6+4=10.

Find Optimal

Day 1: [6,5,4,3,2] + Day 2: [1] gives difficulty 6+1=7. This is optimal!

Dynamic Programming

Use memoization to avoid recalculating the same subproblems for different starting points and remaining days.

Key Takeaway

🎯 Key Insight: This problem has optimal substructure - the best way to schedule remaining jobs depends on previous optimal decisions. DP with memoization avoids recalculating the same subproblems, achieving O(n²d) time complexity instead of exponential.

Asked in

G Google 45 a Amazon 38 f Meta 22 ⊞ Microsoft 18

The optimal solution uses dynamic programming with memoization to solve this job scheduling problem. The key insight is recognizing the optimal substructure: the minimum difficulty for scheduling jobs 0 to i in d days depends on trying all valid ways to end the first day, then optimally scheduling the remaining jobs in d-1 days. Time complexity: O(n²d), Space complexity: O(nd).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Memoized)	O(n²d)	O(nd)	Optimize brute force by caching subproblem results
Recursive Brute Force	O(n^d)	O(d)	Try all possible ways to partition jobs across days

Dynamic Programming (Memoized) — Algorithm Steps

Check if scheduling is possible (jobs >= days)
Create memoization table indexed by (day, start_job)
For each recursive call, check if result is already cached
If not cached, compute result recursively and store it
Return cached result for future identical subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

First Call

Calculate and cache result for (day=2, start=3)

Cache Hit

Same subproblem encountered again - return cached result

Space Trade-off

Use O(nd) space to achieve O(n²d) time complexity

Code -

solution.c — C

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

typedef struct {
    int day;
    int start;
    int result;
} MemoEntry;

MemoEntry memo[1000];
int memoSize = 0;

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

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

int findMemo(int day, int start) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].day == day && memo[i].start == start) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int day, int start, int result) {
    memo[memoSize].day = day;
    memo[memoSize].start = start;
    memo[memoSize].result = result;
    memoSize++;
}

int solve(int* jobs, int n, int d, int day, int start) {
    int cached = findMemo(day, start);
    if (cached != -1) {
        return cached;
    }
    
    if (day == d) {
        int maxVal = 0;
        for (int i = start; i < n; i++) {
            maxVal = max(maxVal, jobs[i]);
        }
        addMemo(day, start, maxVal);
        return maxVal;
    }
    
    int minDiff = INT_MAX;
    int maxSoFar = 0;
    
    for (int i = start; i <= n - d + day; i++) {
        maxSoFar = max(maxSoFar, jobs[i]);
        int remaining = solve(jobs, n, d, day + 1, i + 1);
        minDiff = min(minDiff, maxSoFar + remaining);
    }
    
    addMemo(day, start, minDiff);
    return minDiff;
}

int minimumDifficulty(int* jobDifficulty, int jobDifficultySize, int d) {
    if (jobDifficultySize < d) return -1;
    memoSize = 0;
    return solve(jobDifficulty, jobDifficultySize, d, 1, 0);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int jobDifficulty[100];
    int n = 0;
    
    char* token = strtok(line, "[,]\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            jobDifficulty[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]\n");
    }
    
    int d;
    scanf("%d", &d);
    
    printf("%d\n", minimumDifficulty(jobDifficulty, n, d));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²d)

There are O(nd) unique subproblems, and each takes O(n) time to solve

⚠ Quadratic Growth

Space Complexity

O(nd)

Memoization table stores results for each (day, job_index) combination

⚡ Linearithmic Space

89.2K Views

Medium-High Frequency

~25 min Avg. Time

2.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

Dynamic Programming (Memoized) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler