leetcode_207 Course Schedule (dfs, bfs, 拓扑排序)

问题描述

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, is it possible for you to finish all courses?

Example 1:

Input: 2, [[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: 2, [[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.

思路分析

1. DFS
   课程之间存在着先修的依赖关系，构成了一张有向图，我们要做的事情是判断这个张图里边有没有环，如果有环，表示课程之间存在着循环依赖，那么返回值就应该是False，反之则应该返回True。
   我们访问一个未被访问过的结点，将其标记为不能访问，然后找出其所有子结点（需要的先修课程），如果子节点中出现了先前标记为不能访问的结点，说明出现了环，访问失败，返回False即可。我们依次地用DFS判断这些子节点是否成环，如果所有的子节点都没有问题则返回True，并将当前访问的结点标记为成功访问。
   Python 代码如下

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        pre_dict = [[] for _ in range(numCourses)]
        tested = [0 for _ in range(numCourses)] #初始化为未访问
        def dfs(start_node):
            if tested[start_node] == 1: # 成功访问
                return True
            if tested[start_node] == -1: # 不能访问
                return False
            
            tested[start_node] = -1
            for c in pre_dict[start_node]:
                if not dfs(c):
                    return False
            
            tested[start_node] = 1
            return True
        
        for c_pair in prerequisites:
            pre_dict[c_pair[0]].append(c_pair[1])
        
        for c in range(numCourses):
            if not dfs(c):
                return False
        return True

2. BFS(拓扑排序)
   我们首先计算每个结点结点的入度，也即有多少门课需要它作为先修课。
   所有结点中，必定至少存在一个结点的入度为0，否则，图中必定有环。
   我们遍历未访问的结点，先找到一个入度为0的结点，然后找到它的相邻结点，也即它的先修课集合，然后把它们的入度减一，同时将这个入度为0的结点标记为已访问，也就相当于把这个结点从图中删除了。遍历结束后，如果从始至终都有入度为0的结点，那么说明图中没有环。
   Python 代码如下

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        pre_dict = [[] for _ in range(numCourses)]
        tested = [0 for _ in range(numCourses)]
        indegree = [0 for _ in range(numCourses)]
        
        for c_pair in prerequisites:
            pre_dict[c_pair[0]].append(c_pair[1])
            indegree[c_pair[1]] += 1
        visited = 0            
            
        while visited < numCourses:
            ind = 0 
            while  ind < numCourses and indegree[ind] != 0 :
                ind += 1

            if ind == numCourses:
                return False

            for neighbor in pre_dict[ind]:
                indegree[neighbor] -= 1

            indegree[ind] = -1
            visited +=1
        
        return True