• 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关键字

  • 相关阅读:
    Asp.Net下的DataGrid的多层表头(转自csdn)
    C#中使用DirectX编程 (转)
    Factory Method来实现数据库操作的类 (转) 原文:冷风.NET
    (转)关于定时器,介绍得很好!
    (原创)如何让web页面产生服务器数据返回后仍然能够保留到用户输入的位置!
    最近加入了控件开发团队,发现一些基础的东西,转发上来方便大家学习(转)
    中国共享软件走向国际指南(转,有感而发!)
    水晶报表官方实例大全 (转)
    用VS.NET2003制作WEB应用程序的安装包 (转)
    开发 Windows Mobile 应用程序: FAQ(最近买了ppc,正好打算学习开发使用。)
  • 原文地址:https://www.cnblogs.com/centralpark/p/12905830.html
Copyright © 2020-2023  润新知