Codestin Search App

Parallel Courses - Problem

Imagine you're a university student trying to graduate as quickly as possible! 🎓 You have n courses labeled from 1 to n that you need to complete, but there's a catch - some courses have prerequisites.

You're given an array relations where relations[i] = [prevCoursei, nextCoursei] means you must complete prevCoursei before you can take nextCoursei. The good news? In any semester, you can take unlimited courses as long as you've completed all their prerequisites in previous semesters.

Goal: Find the minimum number of semesters needed to complete all courses. If it's impossible due to circular dependencies (like Course A requires Course B, but Course B requires Course A), return -1.

Example: If you have 3 courses with relations [[1,3],[2,3]], you can take courses 1 and 2 in semester 1, then course 3 in semester 2, requiring 2 semesters total.

Input & Output

example_1.py — Basic Prerequisites

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

› Output: 2

💡 Note: Course 3 requires both courses 1 and 2 as prerequisites. In semester 1, we can take courses 1 and 2 simultaneously since they have no prerequisites. In semester 2, we can take course 3 since its prerequisites (1 and 2) are now satisfied.

example_2.py — Impossible (Cycle)

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

› Output: -1

💡 Note: There's a circular dependency: course 1 requires course 3, course 3 requires course 2, and course 2 requires course 1. This creates a cycle, making it impossible to complete all courses.

example_3.py — Linear Chain

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

› Output: 4

💡 Note: Courses form a linear chain: 1 → 2 → 3 → 4. Each course can only be taken after completing the previous one, so we need 4 semesters total.

Constraints

1 ≤ n ≤ 5000
0 ≤ relations.length ≤ 5000
relations[i].length == 2
1 ≤ prevCoursei, nextCoursei ≤ n
prevCoursei ≠ nextCoursei
All prerequisite relationships are distinct

Visualization

Tap to expand

Understanding the Visualization

Map Dependencies

Create a prerequisite map showing which courses must be completed before others

Find Starting Courses

Identify courses with no prerequisites - these can be taken in the first semester

Semester Planning

Each semester, take all courses whose prerequisites are satisfied

Progress Tracking

After completing courses, update which new courses become available

Cycle Detection

If no courses can be taken but some remain, there's a circular dependency

Key Takeaway

🎯 Key Insight: This is essentially finding the longest path in a DAG - each semester represents a level in the topological ordering, and we can process multiple courses per level simultaneously!

Asked in

G Google 25 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses Kahn's Algorithm for topological sorting. Build a graph with indegrees, then use BFS level-by-level processing where each level represents a semester. Courses with zero indegrees can be taken simultaneously. The algorithm naturally detects cycles and runs in O(V + E) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n²)	O(n)	Simulate semester by semester, checking which courses can be taken
Kahn's Algorithm (Topological Sort)	O(V + E)	O(V + E)	Build indegree array first, then use BFS to process courses level by level

Brute Force Simulation — Algorithm Steps

Initialize a set to track completed courses
For each semester, find courses whose prerequisites are all completed
If no courses can be taken but some remain, return -1 (cycle detected)
Otherwise, mark those courses as completed and increment semester count
Repeat until all courses are completed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

All courses are available to check, none completed

Semester 1

Find courses with no prerequisites and take them

Semester 2

Check remaining courses, take those with satisfied prerequisites

Continue

Repeat until all courses completed or cycle detected

Code -

solution.c — C

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

int minimumSemesters(int n, int** relations, int relationsSize, int* relationsColSize) {
    // Create adjacency list for prerequisites
    bool prereqs[n+1][n+1];
    bool completed[n+1];
    
    // Initialize
    for (int i = 0; i <= n; i++) {
        completed[i] = false;
        for (int j = 0; j <= n; j++) {
            prereqs[i][j] = false;
        }
    }
    
    // Build prerequisite matrix
    for (int i = 0; i < relationsSize; i++) {
        prereqs[relations[i][1]][relations[i][0]] = true;
    }
    
    int completedCount = 0;
    int semesters = 0;
    
    while (completedCount < n) {
        int canTake[n];
        int canTakeCount = 0;
        
        for (int course = 1; course <= n; course++) {
            if (!completed[course]) {
                bool canTakeCourse = true;
                for (int prereq = 1; prereq <= n; prereq++) {
                    if (prereqs[course][prereq] && !completed[prereq]) {
                        canTakeCourse = false;
                        break;
                    }
                }
                if (canTakeCourse) {
                    canTake[canTakeCount++] = course;
                }
            }
        }
        
        if (canTakeCount == 0) return -1;
        
        for (int i = 0; i < canTakeCount; i++) {
            completed[canTake[i]] = true;
            completedCount++;
        }
        
        semesters++;
    }
    
    return semesters;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we scan all n courses for each of n semesters

⚠ Quadratic Growth

Space Complexity

O(n)

Space for tracking completed courses

⚡ Linearithmic Space

47.8K Views

Medium Frequency

~15 min Avg. Time

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