Course Schedule II解答

Question

There are a total of n courses you have to take, labeled from 0 to n-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, return the ordering of courses you should take to finish all courses.

There may be multiple correct orders, you just need to return one of them. If it is impossible to finish all courses, return an empty array.

Solution

Like Course Schedule problem, we can use DFS or BFS to solve this problem.

DFS

class Solution:
    def dfs(self, cur: int, adjacencyList: List[List[int]], visited: List[int], result: List[int]) -> bool:
        visited[cur] = 1
        neighbors = adjacencyList[cur]
        for neighbor in neighbors:
            if visited[neighbor] == 1:
                return False
            if visited[neighbor] == 0:
                if not self.dfs(neighbor, adjacencyList, visited, result):
                    return False
        visited[cur] = 2
        result.append(cur)
        return True
        
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        result = []
        if not prerequisites:
            for i in range(numCourses):
                result.append(i)
            return result
        # Build adjacency list
        adjacencyList = [[] for i in range(numCourses)]
        for pair in prerequisites:
            adjacencyList[pair[0]].append(pair[1])
        # Build visited queue: 0 means unvisited; 1 means start to visit; 2 means complete visit
        visited = [0] * numCourses
        for i in range(numCourses):
            if visited[i] == 0:
                dfs_result = self.dfs(i, adjacencyList, visited, result)
                if not dfs_result:
                    return []
        return result

BFS

class Solution:
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        result = []
        if not prerequisites:
            for i in range(numCourses):
                result.append(i)
            return result
        # Build adjacency list
        adjacencyList = [[] for i in range(numCourses)]
        for pair in prerequisites:
            adjacencyList[pair[1]].append(pair[0])
        # Build in-coming edges number list
        edges = [0] * numCourses
        for i in range(numCourses):
            neighbors = adjacencyList[i]
            for neighbor in neighbors:
                edges[neighbor] += 1
        # Build queue to store in-coming edges = 0
        zero_incoming = []
        for i in range(numCourses):
            if edges[i] == 0:
                zero_incoming.append(i)
        if not zero_incoming:
            return []
        # Begin BFS
        count = 0
        while zero_incoming:
            curr = zero_incoming.pop()
            count += 1
            result.append(curr)
            curr_neighbors = adjacencyList[curr]
            for neighbor in curr_neighbors:
                edges[neighbor] -= 1
                if edges[neighbor] == 0:
                    zero_incoming.append(neighbor)
        if count != numCourses:
            return []
        return result