210. Course Schedule II

There are a total of numCourses courses you have to take, labeled from 0 to numCourses - 1. You are given an array prerequisites where prerequisites[i] = [ai, bi] indicates that you must take course bi first if you want to take course ai.

For example, the pair [0, 1], indicates that to take course 0 you have to first take course 1.
Return the ordering of courses you should take to finish all courses. If there are many valid answers, return any of them. If it is impossible to finish all courses, return an empty array.

Example 1:

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

Example 2:

Input: numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
Output: [0,2,1,3]
Explanation: There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0.
So one correct course order is [0,1,2,3]. Another correct ordering is [0,2,1,3].

Example 3:

Input: numCourses = 1, prerequisites = []
Output: [0]

class Solution:
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        
     #the labeled from 0 to n-1,and these are basically going to be the node in our graphs, so it is a graph problem
    #topological sort拓扑排序
    # we are going to run depth first search on the node
    # we need to build an adjacency list邻接表 we need to node each node which is it neighbors,we can get a prerequisites map. so *** has the outgoing, which means these ar *** prerequisites
        prereq = {c:[] for c in range(numCourses)}
    #we are going to iterate through every single course, prere pair in our orerequisites
        for crs, pre in prerequisites:
            prereq[crs].append(pre)
        # a course has three possible status:
                #1.visited: crs has been added to the output
                #2.visiting: crs not added to the output, but added to cycle
                #3.unvisited: crs not added to the output or cycle
        # so we are going to build the output, so we're going do depth for search starting at every single node
        output = []
        # we can use hashset to remember out current path we can recognize when we detect a cycle
        visit, cycle = set(), set()
        # define out dfs function
        def dfs(crs):
            # if we detect any cycles, we have to return an empty[] list, because that means the topological sort is not even possible
            if crs in cycle:  # the first thing is detect cycle
                return False

            if crs in visit: # we don't need to visit twice
                return True
            cycle.add(crs)
        # now we go through every prerequisites of this course
            for pre in prereq[crs]:
                if dfs(pre) == False:
                    return False
            #not a cycle, continue go for search
            cycle.remove(crs) # because it no longer be the path
            visit.add(crs)
            output.append(crs) # finally add to output
            return True
        for c in range(numCourses):
            if dfs(c) == False:
                return []
        return output
            

    #E:edges V:vertices顶点
    # time complexity: O(E + V)