Parallel Courses III - Practice Coding Problems

Parallel Courses III - Problem

Parallel Courses III is an advanced scheduling problem where you need to find the minimum time to complete all university courses given prerequisite constraints.

You have n courses labeled from 1 to n, where each course has:
• A specific duration (in months) to complete
• Zero or more prerequisite courses that must be finished first

Key Rules:
• You can start any course immediately if all its prerequisites are met
• Multiple courses can be taken simultaneously (parallel processing)
• The goal is to minimize total completion time

Input: Number of courses n, prerequisite relationships relations[][], and course durations time[]
Output: Minimum months needed to complete all courses

Think of this as optimizing a project timeline where some tasks depend on others, but independent tasks can run in parallel.

Input & Output

example_1.py — Linear Chain

$ Input: n = 3, relations = [[1,3],[2,3]], time = [3,2,5]

› Output: 8

💡 Note: Courses 1 and 2 can start simultaneously and finish at months 3 and 2 respectively. Course 3 can start at month 3 (when both prerequisites are done) and finishes at month 3+5=8.

example_2.py — Single Course

$ Input: n = 1, relations = [], time = [1]

› Output: 1

💡 Note: Only one course with no prerequisites, takes 1 month to complete.

example_3.py — Complex Dependencies

$ Input: n = 5, relations = [[1,5],[2,5],[3,5],[3,4],[4,5]], time = [1,2,3,4,5]

› Output: 12

💡 Note: Course 3 finishes at month 3, course 4 at month 7 (3+4), and course 5 at month 12 (7+5). Courses 1 and 2 finish earlier but don't affect the critical path.

Constraints

1 ≤ n ≤ 5 × 10⁴
0 ≤ relations.length ≤ min(5000, n × (n - 1) / 2)
relations[j].length == 2
1 ≤ prevCourse_j, nextCourse_j ≤ n
prevCourse_j ≠ nextCourse_j
All the pairs [prevCourse_j, nextCourse_j] are unique
time.length == n
1 ≤ time[i] ≤ 10⁴
The given graph is a directed acyclic graph (DAG)

Visualization

Tap to expand

Understanding the Visualization

Map Dependencies

Build a graph where edges represent prerequisite relationships

Find Starting Courses

Identify courses with no prerequisites - these can start immediately

Process in Order

Use topological sorting to process courses in dependency order

Calculate Times

For each course, its earliest start time is when all prerequisites are done

Key Takeaway

🎯 Key Insight: The minimum time is determined by the longest dependency chain (critical path), not the sum of all course times. Parallel execution of independent courses is automatically optimized through topological sorting.

Asked in

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

The optimal approach uses Topological Sort with Dynamic Programming. Build a directed graph from prerequisites, then process courses in topological order while maintaining the earliest completion time for each course. The key insight is that a course's completion time equals the maximum of all prerequisite completion times plus its own duration. This runs in O(n + m) time where n is courses and m is prerequisites.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(T * n²)	O(n)	Simulate every possible month, starting courses when prerequisites are met
Topological Sort with DP	O(n + m)	O(n + m)	Use topological ordering to calculate earliest completion times with dynamic programming

Brute Force Simulation — Algorithm Steps

Initialize tracking arrays for course start/end times
For each month from 0 to maximum possible time:
Check which courses can start (prerequisites done)
Update running courses and mark completed ones
Return the month when last course finishes

Visualization

Tap to expand

Step-by-Step Walkthrough

Month 0

Start courses with no prerequisites

Month 1-3

Continue running courses, start new ones as prerequisites complete

Final Month

Last course completes, return total time

Code -

solution.c — C

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

int minimumTime(int n, int** relations, int relationsSize, int* time) {
    // Build prerequisite adjacency lists
    int** prereqs = (int**)calloc(n + 1, sizeof(int*));
    int* prereqCounts = (int*)calloc(n + 1, sizeof(int));
    
    // Count prerequisites for each course
    for (int i = 0; i < relationsSize; i++) {
        prereqCounts[relations[i][1]]++;
    }
    
    // Allocate prerequisite arrays
    for (int i = 1; i <= n; i++) {
        if (prereqCounts[i] > 0) {
            prereqs[i] = (int*)malloc(prereqCounts[i] * sizeof(int));
        }
        prereqCounts[i] = 0; // Reset for indexing
    }
    
    // Fill prerequisite arrays
    for (int i = 0; i < relationsSize; i++) {
        int course = relations[i][1];
        prereqs[course][prereqCounts[course]++] = relations[i][0];
    }
    
    bool* completed = (bool*)calloc(n + 1, sizeof(bool));
    int* completionTime = (int*)calloc(n + 1, sizeof(int));
    
    int month = 0;
    while (true) {
        bool allDone = true;
        for (int i = 1; i <= n; i++) {
            if (!completed[i]) {
                allDone = false;
                break;
            }
        }
        if (allDone) break;
        
        month++;
    }
    
    // Find maximum completion time
    int maxTime = 0;
    for (int i = 1; i <= n; i++) {
        if (completionTime[i] > maxTime) {
            maxTime = completionTime[i];
        }
    }
    
    // Cleanup
    for (int i = 1; i <= n; i++) {
        if (prereqs[i]) free(prereqs[i]);
    }
    free(prereqs);
    free(prereqCounts);
    free(completed);
    free(completionTime);
    
    return maxTime;
}

Time & Space Complexity

Time Complexity

⏱️

O(T * n²)

T is maximum time (sum of all durations), for each month we check n courses and their prerequisites

⚠ Quadratic Growth

Space Complexity

O(n)

Arrays to track course states and completion times

⚡ Linearithmic Space

52.0K Views

High Frequency

~25 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler