Parallel Courses III

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

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

✓ Brute Force Simulation

⏱️ Time: O(T * n²) Space: O(n)

Month by month, check which courses can start (prerequisites completed), run them for their duration, and continue until all courses finish. This approach simulates the actual timeline step by step.

Topological Sort with DP

⏱️ Time: O(n + m) Space: O(n + m)

First, build a graph and calculate in-degrees. Then use Kahn's algorithm for topological sorting while maintaining the earliest completion time for each course using dynamic programming. This approach processes courses in dependency order.

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 <string.h>

int n;
int *timeArr;
int **adj;
int *adjSize;
int *memo;
int *visited;

int dfs(int course) {
    if (memo[course] != -1) {
        return memo[course];
    }
    
    if (visited[course]) {
        return 0;
    }
    
    visited[course] = 1;
    
    int maxPrereqTime = 0;
    for (int i = 0; i < adjSize[course]; i++) {
        int prereq = adj[course][i];
        int prereqTime = dfs(prereq);
        if (prereqTime > maxPrereqTime) {
            maxPrereqTime = prereqTime;
        }
    }
    
    memo[course] = maxPrereqTime + timeArr[course - 1];
    return memo[course];
}

int minimumTime(int n_param, int** relations, int relationsSize, int* time) {
    n = n_param;
    timeArr = time;
    
    // Build adjacency list (prerequisites for each course)
    adj = (int**)calloc(n + 1, sizeof(int*));
    adjSize = (int*)calloc(n + 1, sizeof(int));
    int *adjCap = (int*)calloc(n + 1, sizeof(int));
    
    // Count prerequisites
    for (int i = 0; i < relationsSize; i++) {
        int to = relations[i][1];
        adjSize[to]++;
    }
    
    // Allocate
    for (int i = 1; i <= n; i++) {
        if (adjSize[i] > 0) {
            adj[i] = (int*)malloc(adjSize[i] * sizeof(int));
            adjCap[i] = adjSize[i];
            adjSize[i] = 0;
        }
    }
    
    // Fill adjacency list
    for (int i = 0; i < relationsSize; i++) {
        int from = relations[i][0];
        int to = relations[i][1];
        adj[to][adjSize[to]++] = from;
    }
    
    memo = (int*)malloc((n + 1) * sizeof(int));
    visited = (int*)calloc(n + 1, sizeof(int));
    for (int i = 0; i <= n; i++) {
        memo[i] = -1;
    }
    
    int maxTime = 0;
    for (int course = 1; course <= n; course++) {
        int t = dfs(course);
        if (t > maxTime) {
            maxTime = t;
        }
    }
    
    // Cleanup
    for (int i = 1; i <= n; i++) {
        if (adj[i]) free(adj[i]);
    }
    free(adj);
    free(adjSize);
    free(adjCap);
    free(memo);
    free(visited);
    
    return maxTime;
}

static int relations[5000][2];
static int time_arr[50000];

int parseRelations(char* str, int relationsArray[][2]) {
    int count = 0;
    
    if (strcmp(str, "[]") == 0) {
        return 0;
    }
    
    char* ptr = str;
    while (*ptr) {
        while (*ptr && *ptr != '[') ptr++;
        if (!*ptr) break;
        ptr++;
        
        if (*ptr == '[' || *ptr == ']') continue;
        
        char *end;
        int a = (int)strtol(ptr, &end, 10);
        if (ptr == end) break;
        ptr = end;
        
        while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
        
        int b = (int)strtol(ptr, &end, 10);
        if (ptr == end) break;
        ptr = end;
        
        relationsArray[count][0] = a;
        relationsArray[count][1] = b;
        count++;
        
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr == ']') ptr++;
    }
    
    return count;
}

int parseTime(char* str, int* timeArray) {
    int count = 0;
    char* ptr = str;
    
    // Skip '[' if present
    while (*ptr && (*ptr == '[' || *ptr == ' ')) ptr++;
    
    while (*ptr && *ptr != ']') {
        char *end;
        int val = (int)strtol(ptr, &end, 10);
        if (ptr == end) break;
        timeArray[count++] = val;
        ptr = end;
        while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
    }
    
    return count;
}

int main() {
    char line[100000];
    
    fgets(line, sizeof(line), stdin);
    int n = atoi(line);
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    int relationsSize = parseRelations(line, relations);
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    parseTime(line, time_arr);
    
    int** relationsPtr = NULL;
    if (relationsSize > 0) {
        relationsPtr = (int**)malloc(relationsSize * sizeof(int*));
        for (int i = 0; i < relationsSize; i++) {
            relationsPtr[i] = relations[i];
        }
    }
    
    int result = minimumTime(n, relationsPtr, relationsSize, time_arr);
    printf("%d\n", result);
    
    if (relationsPtr) free(relationsPtr);
    return 0;
}

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