Parallel Courses

Parallel Courses - Problem

You are given an integer n, which indicates that there are n courses labeled from 1 to n. You are also given an array relations where relations[i] = [prevCoursei, nextCoursei], representing a prerequisite relationship between course prevCoursei and course nextCoursei: course prevCoursei has to be taken before course nextCoursei.

In one semester, you can take any number of courses as long as you have taken all the prerequisites in the previous semester for the courses you are taking.

Return the minimum number of semesters needed to take all courses. If there is no way to take all the courses, return -1.

Input & Output

Example 1 — Basic Prerequisites

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

› Output: 2

💡 Note: Course 1 and 2 have no prerequisites, so take them in semester 1. Course 3 requires both 1 and 2, so take it in semester 2.

Example 2 — Chain Dependencies

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

› Output: 3

💡 Note: Course 1 → Course 2 → Course 3 forms a chain. Need 3 semesters: semester 1 (course 1), semester 2 (course 2), semester 3 (course 3).

Example 3 — Impossible Case

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

› Output: -1

💡 Note: Course 1 requires 2 and course 2 requires 1, creating a cycle. Impossible to complete all courses.

Constraints

1 ≤ n ≤ 5000
0 ≤ relations.length ≤ 5000
relations[i].length == 2
1 ≤ prevCoursei, nextCoursei ≤ n
prevCoursei ≠ nextCoursei
All the pairs [prevCoursei, nextCoursei] are unique

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 32 f Facebook 28 M Microsoft 25

The key insight is to use topological sorting with BFS to process courses level by level. Each BFS level represents one semester where we can take all courses with no remaining prerequisites. Best approach is Kahn's algorithm with level-by-level processing. Time: O(V + E), Space: O(V + E).

Common Approaches

✓ BFS Topological Sort (Kahn's Algorithm)

⏱️ Time: O(V + E) Space: O(V + E)

Build a graph of prerequisites and use topological sorting with BFS. Each BFS level represents one semester, allowing us to take all courses with no remaining prerequisites simultaneously.

Brute Force - Try All Orderings

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

Try every possible way to arrange courses and check if prerequisites are satisfied. For each valid arrangement, count the minimum semesters needed.

BFS Topological Sort (Kahn's Algorithm) — Algorithm Steps

Calculate indegree for each course
Start BFS with courses having indegree 0
Process one level at a time, each level is one semester
Reduce indegree of dependent courses

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list and calculate indegrees

Level-by-Level BFS

Process all courses with indegree 0 in current semester

Update Dependencies

Reduce indegree of dependent courses after completion

Code -

solution.c — C

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

static int graph[1001][1001];
static int graphSize[1001];
static int indegree[1001];
static int queue[1001];

int solution(int n, int relations[][2], int relationsSize) {
    if (n == 0) {
        return 0;
    }
    if (relationsSize == 0) {
        return 1;
    }
    
    // Initialize
    memset(indegree, 0, sizeof(int) * (n + 1));
    memset(graphSize, 0, sizeof(int) * (n + 1));
    
    // Build graph and indegree
    for (int i = 0; i < relationsSize; i++) {
        int prev = relations[i][0];
        int nextCourse = relations[i][1];
        graph[prev][graphSize[prev]++] = nextCourse;
        indegree[nextCourse]++;
    }
    
    // Find courses with no prerequisites
    int front = 0, rear = 0;
    for (int course = 1; course <= n; course++) {
        if (indegree[course] == 0) {
            queue[rear++] = course;
        }
    }
    
    int semesters = 0;
    int coursesTaken = 0;
    
    while (front < rear) {
        // Process all courses in current semester
        int levelSize = rear - front;
        coursesTaken += levelSize;
        semesters++;
        
        int newRear = rear;
        for (int i = 0; i < levelSize; i++) {
            int course = queue[front++];
            
            // Reduce indegree of dependent courses
            for (int j = 0; j < graphSize[course]; j++) {
                int nextCourse = graph[course][j];
                indegree[nextCourse]--;
                if (indegree[nextCourse] == 0) {
                    queue[newRear++] = nextCourse;
                }
            }
        }
        rear = newRear;
    }
    
    // If we couldn't take all courses, there's a cycle
    return coursesTaken == n ? semesters : -1;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    fgets(line, sizeof(line), stdin); // consume newline
    fgets(line, sizeof(line), stdin);
    
    int relations[1000][2];
    int relationsSize = 0;
    
    // Parse array manually
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++; // find first '['
    
    if (*ptr == '[') {
        ptr++; // skip '['
        
        while (*ptr && *ptr != ']') {
            if (*ptr == '[') {
                ptr++; // skip inner '['
                relations[relationsSize][0] = (int)strtol(ptr, &ptr, 10);
                while (*ptr && *ptr != ',') ptr++; // find comma
                if (*ptr == ',') ptr++; // skip comma
                relations[relationsSize][1] = (int)strtol(ptr, &ptr, 10);
                relationsSize++;
                while (*ptr && *ptr != ']') ptr++; // find inner ']'
                if (*ptr == ']') ptr++; // skip inner ']'
            } else {
                ptr++;
            }
        }
    }
    
    printf("%d\n", solution(n, relations, relationsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each course once (V) and each prerequisite relation once (E)

✓ Linear Growth

Space Complexity

O(V + E)

Store adjacency list (E edges) and indegree array (V vertices)

✓ Linear Space

28.0K Views

Medium Frequency

~25 min Avg. Time

892 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

BFS Topological Sort (Kahn's Algorithm) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler