Parallel Courses in Python

The parallel courses problem involves finding the minimum number of semesters needed to complete N courses with prerequisite dependencies. This is essentially a topological sorting problem that can be solved using BFS (Breadth-First Search).

Problem Understanding

Given N courses labeled 1 to N and a relations array where relations[i] = [X, Y] means course X must be completed before course Y. We need to find the minimum semesters required to complete all courses, or return -1 if impossible due to circular dependencies.

Algorithm Approach

We use topological sorting with BFS to process courses level by level ?

• Build a directed graph representing course dependencies

• Calculate in-degree (number of prerequisites) for each course

• Start with courses having zero prerequisites

• Process courses semester by semester using BFS

• Return -1 if circular dependency exists

Implementation

from collections import deque

class Solution:
    def minimumSemesters(self, n, relations):
        # Build graph and calculate in-degrees
        graph = [[] for _ in range(n + 1)]
        in_degree = [0] * (n + 1)
        
        for prerequisite, course in relations:
            graph[prerequisite].append(course)
            in_degree[course] += 1
        
        # Find courses with no prerequisites
        queue = deque()
        for course in range(1, n + 1):
            if in_degree[course] == 0:
                queue.append(course)
        
        semester = 0
        completed_courses = 0
        
        # Process courses semester by semester
        while queue:
            semester += 1
            current_semester_size = len(queue)
            
            # Process all courses in current semester
            for _ in range(current_semester_size):
                current_course = queue.popleft()
                completed_courses += 1
                
                # Update prerequisites for dependent courses
                for next_course in graph[current_course]:
                    in_degree[next_course] -= 1
                    if in_degree[next_course] == 0:
                        queue.append(next_course)
        
        # Return result: semesters if all completed, -1 if circular dependency
        return semester if completed_courses == n else -1

# Test the solution
solution = Solution()
print(solution.minimumSemesters(3, [[1,3],[2,3]]))
print(solution.minimumSemesters(3, [[1,2],[2,3],[3,1]]))

2
-1

How It Works

Let's trace through the example with N = 3, relations = [[1,3],[2,3]] ?

1. Build graph: Course 1 ? Course 3, Course 2 ? Course 3

2. Calculate in-degrees: Course 1: 0, Course 2: 0, Course 3: 2

3. Semester 1: Process courses 1 and 2 (zero prerequisites)

4. Update: Course 3's in-degree becomes 0

5. Semester 2: Process course 3

6. Result: 2 semesters needed

Key Features

Conclusion

This solution uses topological sorting with BFS to find the minimum semesters needed for course completion. The algorithm efficiently handles prerequisite dependencies and detects circular dependencies that make completion impossible.