解法1 DFS
思路：最先被放入栈中的节点是在拓扑排序中最后面的节点
一开始用了DFS，但是出现了问题
DFS函数在正确处理循环检测方面存在问题：
循环检测逻辑问题：在您的DFS中，您检查一个课程是否已被访问，如果已被访问，则立即将 valid 设置为 False。这种方式并没有正确区分处于当前路径中的节点（表示存在循环）与之前遍历中已访问过的节点（不属于循环）。
为了解决这个问题：
标记当前路径中的节点：为了正确处理循环检测，您应该使用另一个集合来跟踪当前路径中的节点。如果您遇到已在此集合中的节点，那么就发现了一个循环。
但是leetcode使用了一个trick，在visited中用不同的值 0 1 2来标记unvisited，ontrack，finished，而不是像我一样创建了三个数据结构，这非常好。
以下是根据你提供的URL内容的Markdown格式转换：
207. 课程表 - 力扣（LeetCode）
对于图中的任意一个节点，它在搜索的过程中有三种状态，即：
- 未搜索：我们还没有搜索到这个节点；
- 搜索中：我们搜索过这个节点，但还没有回溯到该节点，即该节点还没有入栈，还有相邻的节点没有搜索完成；
- 已完成：我们搜索过并且回溯过这个节点，即该节点已经入栈，并且所有该节点的相邻节点都出现在栈的更底部的位置，满足拓扑排序的要求。
通过上述的三种状态，我们就可以给出使用深度优先搜索得到拓扑排序的算法流程，在每一轮的搜索搜索开始时，我们任取一个「未搜索」的节点开始进行深度优先搜索。
我们将当前搜索的节点 uuu 标记为「搜索中」，遍历该节点的每一个相邻节点 vvv：
- 如果 vvv 为「未搜索」，那么我们开始搜索 vvv，待搜索完成回溯到 uuu；
- 如果 vvv 为「搜索中」，那么我们就找到了图中的一个环，因此是不存在拓扑排序的；
- 如果 vvv 为「已完成」，那么说明 vvv 已经在栈中了，而 uuu 还不在栈中，因此 uuu 无论何时入栈都不会影响到 (u,v)(u, v)(u,v) 之前的拓扑关系，以及不用进行任何操作。
当 uuu 的所有相邻节点都为「已完成」时，我们将 uuu 放入栈中，并将其标记为「已完成」。
在整个深度优先搜索的过程结束后，如果我们没有找到图中的环，那么栈中存储这所有的 nnn 个节点，从栈顶到栈底的顺序即为一种拓扑排序。
作者：力扣官方题解
链接：官解
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
edges = collections.defaultdict(list)
visited = [0] * numCourses
result = list()
valid = True
for info in prerequisites:
edges[info[1]].append(info[0])
def dfs(u: int):
nonlocal valid
visited[u] = 1
for v in edges[u]:
if visited[v] == 0:
dfs(v)
if not valid:
return
elif visited[v] == 1:
valid = False
return
visited[u] = 2
result.append(u)
for i in range(numCourses):
if valid and not visited[i]:
dfs(i)
return valid
正确解答：
class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
def dfs(node):
nonlocal valid
if not valid:
return
visited.add(node)
on_path.add(node)
for course in requirements[node]:
if course not in visited:
dfs(course)
elif course in on_path:
valid = False
return
on_path.remove(node)
requirements = [[] for _ in range(numCourses)]
for course, prerequisite in prerequisites:
requirements[prerequisite].append(course)
visited = set()
on_path = set()
valid = True
for course in range(numCourses):
if not valid:
return False
if course not in visited:
dfs(course)
return valid
错误解答：
class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
def dfs(node):
nonlocal valid
if not valid:
return
visited.add(node)
for course in requirements[node]:
if course not in visited:
dfs(course)
else:
valid = False
return
requirements = [[] for _ in range(numCourses)]
for course, prerequisite in prerequisites:
requirements[prerequisite].append(course)
visited = set()
valid = True
for requirement in range(numCourses):
if not valid:
return False
if requirement not in visited:
dfs(requirement)
return valid
解法2 BFS
这也是我更加喜欢的方法
深度优先搜索是一种「逆向思维」：最先被放入栈中的节点是在拓扑排序中最后面的节点。我们也可以使用正向思维，顺序地生成拓扑排序，这种方法也更加直观。
我们考虑拓扑排序中最前面的节点，该节点一定不会有任何入边，也就是它没有任何的先修课程要求。当我们将一个节点加入答案中后，我们就可以移除它的所有出边，代表着它的相邻节点少了一门先修课程的要求。如果某个相邻节点变成了「没有任何入边的节点」，那么就代表着这门课可以开始学习了。按照这样的流程，我们不断地将没有入边的节点加入答案，直到答案中包含所有的节点（得到了一种拓扑排序）或者不存在没有入边的节点（图中包含环）。
上面的想法类似于广度优先搜索，因此我们可以将广度优先搜索的流程与拓扑排序的求解联系起来。
算法
我们使用一个队列来进行广度优先搜索。初始时，所有入度为 0 的节点都被放入队列中，它们就是可以作为拓扑排序最前面的节点，并且它们之间的相对顺序是无关紧要的。
在广度优先搜索的每一步中，我们取出队首的节点 u：
- 我们将
u放入答案中； - 我们移除
u的所有出边，也就是将u的所有相邻节点的入度减少 1。如果某个相邻节点v的入度变为 0，那么我们就将v放入队列中。
在广度优先搜索的过程结束后。如果答案中包含了这 n 个节点，那么我们就找到了一种拓扑排序，否则说明图中存在环，也就不存在拓扑排序了。
来源：力扣（LeetCode）
作者：力扣官方题解
链接：力扣官方题解
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
edges = collections.defaultdict(list)
indeg = [0] * numCourses
for info in prerequisites:
edges[info[1]].append(info[0])
indeg[info[0]] += 1
q = collections.deque([u for u in range(numCourses) if indeg[u] == 0])
visited = 0
while q:
visited += 1
u = q.popleft()
for v in edges[u]:
indeg[v] -= 1
if indeg[v] == 0:
q.append(v)
return visited == numCourses