LC207. 课程表

DFS遍历结合路径判断是否有环
dfs的意思是从当前结点出发能够访问到所有的节点。
如果从当前节点出发能够访问到同一个几点两次，说明出现环了

def canFinish(self, numCourses, prerequisites):
        """
        :type numCourses: int
        :type prerequisites: List[List[int]]
        :rtype: bool
        """
        g = [[]for _ in range(numCourses)]          #邻接表
        for x,y in prerequisites:
            g[y].append(x)      #这里x的入度加1，y的出度加1。邻接表存储的是依赖于y的节点也就是y指向的节点。
        visited = [0]*numCourses
        def dfs(g,i):                               #深度优先遍历
            if  visited[i] == 1:   #从一个节点出发访问到同一个节点两次，说明有环
                return False
            if visited[i] == 2:    #遇到的是前面路径里访问过且没遇到环的，也不会出现环，有环的话在第一次遇到这节点时就会访问到环
            	  return True
            visited[i] = 1                          #标记访问过
            for course in g[i]:
                if not dfs(g,course):
                    return False
            visited[i] = 2                          #这条路径访问完了，返回
            return True												  #for循环之外，for循环执行完才会执行
        for i in range(numCourses):
            if not dfs(g,i):
                return False
        return True

BFS

def canFinish(self, numCourses, prerequisites):
        """
        :type numCourses: int
        :type prerequisites: List[List[int]]
        :rtype: bool
        """
        flag = 0
        g = [[]for _ in range(numCourses)]
        degree = [0]*numCourses
        for x,y in prerequisites:
            g[y].append(x)        #注意邻接表的建立方式不同导致返回的后序遍历结果顺序不同。这里x的入度加1，y的出度+1。邻接表存储的是依赖于y的节点也就是y指向的节点。
            degree[x] += 1
        queue = deque()
        for i in range(len(degree)):
            if degree[i] == 0:
                queue.append(i)
        while queue:
            for i in range(len(queue)):
                node = queue.popleft()
                flag += 1
                for j in g[node]:
                    degree[j] -= 1
                    if degree[j] == 0:
                        queue.append(j)
        if flag == numCourses:
            return True
        else:
            return False