LeetCode 207. Course Schedule

Description

https://leetcode.com/problems/course-schedule/

There are a total of numCourses courses you have to take, labeled from 0 to numCourses-1.

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]

Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?

Example 1:

Input: numCourses = 2, prerequisites = [[1,0]]
Output: true
Explanation: There are a total of 2 courses to take. 
             To take course 1 you should have finished course 0. So it is possible.

Example 2:

Input: numCourses = 2, prerequisites = [[1,0],[0,1]]
Output: false
Explanation: There are a total of 2 courses to take. 
             To take course 1 you should have finished course 0, and to take course 0 you should
             also have finished course 1. So it is impossible.

Constraints:

• The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.
• You may assume that there are no duplicate edges in the input prerequisites.
• 1 <= numCourses <= 10^5

Explanation

topological sort

Python Solution

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        graph = [[] for i in range(numCourses)]
        in_degree = [0] * numCourses
        
        for to_node, from_node in prerequisites:
            graph[from_node].append(to_node)
            in_degree[to_node] += 1
            
        num_choose = 0
        queue = deque()
        
        for i in range(numCourses):
            if in_degree[i] == 0:
                queue.append(i)
                
        while queue:
            current_node = queue.popleft()
            num_choose += 1
            
            for next_node in graph[current_node]:
                in_degree[next_node] -= 1
                if in_degree[next_node] == 0:
                    queue.append(next_node)
                    
        return num_choose == numCourses

• Time Complexity: ~V + E
• Space Complexity: ~V + E

where V is the number of courses, and E is the number of dependencies.