210. 课程表 II

题目:共有 n 门课需要选,记为 0 到 n-1。在选修某些课程之前需要一些先修课程。 例如,想要学习课程 0 ,你需要先完成课程 1 ,我们用一个匹配来表示他们: [0,1给定课程总量以及它们的先决条件,返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序,你只要返回一种就可以了。如果不可能完成所有课程,返回一个空数组。

本题为拓扑排序问题。根据课程关系列表生成先修课程->课程的有向图。查找正确课程顺序。

法一:DFS

DFS是逆向思维,从任一节点开始向后寻找后继课程节点,直到节点没有后继课程。“深度优先”的过程就是从任一节点一直向后查找的过程。
用一个栈来存储所有已经搜索完成的节点。选任一节点进行深度优先搜索,直到找到一个没有相邻节点的节点,指它所有的后继课程全部入栈完成,那么此时可以将这个节点入栈,即根据栈的反序,所有以该节点为先修课程的节点都在该节点的顺序之后。然后回溯节点,继续进行深度优先搜索,直到所有相邻节点全部入栈。如果搜索过程中检索到相邻节点为正在搜索的节点(不可能搜索到已经入栈的节点,因为已经入栈的节点说明所有后续节点都入栈完成,在环中的节点其后续也是前驱),那么图中有环。最后出栈输出所有节点正确顺序。

Time:O(m+n),其中n为课程数,m为先修课程的关系数。对图进行DFS遍历的时间复杂度。
Space:O(m+n),存储图的邻接表O(m),栈空间O(n)

#python
class Solution:
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        # 存储有向图
        edges = collections.defaultdict(list)
        # 标记每个节点的状态:0=未搜索,1=搜索中,2=已完成
        visited = [0] * numCourses
        # 用数组来模拟栈,下标 0 为栈底,n-1 为栈顶
        result = list()
        # 判断有向图中是否有环
        invalid = False
        #遍历课程关系列表,将(课程,[后续课程])存入edges中
        for info in prerequisites:
            edges[info[1]].append(info[0])
        
        def dfs(u: int):
            nonlocal invalid
            # 将节点标记为「搜索中」
            visited[u] = 1
            # 搜索其相邻节点
            # 只要发现有环,立刻停止搜索
            for v in edges[u]:
                # 如果「未搜索」那么搜索相邻节点
                if visited[v] == 0:
                    dfs(v)
                    if invalid:
                        return
                # 如果「搜索中」说明找到了环
                elif visited[v] == 1:
                    invalid = True
                    return
            # 将节点标记为「已完成」
            visited[u] = 2
            # 将节点入栈
            result.append(u)
        
        # 每次挑选一个「未搜索」的节点,开始进行深度优先搜索
        for i in range(numCourses):
            if not invalid and not visited[i]:
                dfs(i)
        
        if invalid:
            return list()
        
        # 如果没有环,那么就有拓扑排序
        # 注意下标 0 为栈底,因此需要将数组反序输出
        return result[::-1]

法二:BFS

BFS和拓扑排序的结合是正向思维的方法。考虑拓扑排序最前面的节点,节点没有入边,将入度为0的节点加入队列,同时将节点所有出边移除,即将节点的所有相邻节点的入度减1,循环将入度为0的节点加入队列,直到没有入度为0的节点,检验是否存在剩余节点,若存在,即包含环。“广度优先”的过程就是查找一个节点的所有相邻节点处理入度。

Time:O(m+n),其中n为课程数,m为先修课程的关系数。对图进行BFS遍历的时间复杂度。
Space:O(m+n),存储图的邻接表O(m),队列空间O(n)

class Solution:
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        # 根据先修关系建立有向图字典 k,v=>课程,先修课程
        edges = collections.defaultdict(list)
        # 存储每个节点的入度
        indeg = [0] * numCourses
        # 存储答案
        result = list()
        
        for info in prerequisites:
            edges[info[1]].append(info[0])
            indeg[info[0]] += 1
        
        # 将所有入度为 0 的节点放入队列中
        q = collections.deque([u for u in range(numCourses) if indeg[u] == 0])

        while q:
            # 从队首取出一个节点
            u = q.popleft()
            # 放入答案中
            result.append(u)
            for v in edges[u]:
                indeg[v] -= 1
                # 如果相邻节点 v 的入度为 0,就可以选 v 对应的课程了
                if indeg[v] == 0:
                    q.append(v)

        if len(result) != numCourses:
            result = list()
        return result

1.dict setdefault函数和collections.defaultdict函数
2.python中global和nonlocal关键字

原文地址:https://www.cnblogs.com/centralpark/p/12905830.html