leetcode - 210. Course Schedule II_210.course schedule c语言-优快云博客

本文链接：https://blog.youkuaiyun.com/Quiteen/article/details/66474558

算法系列博客之拓扑排序

拓扑排序在实际生活中的应用非常的广泛，比如自动生成课表，时间安排表等等，也正是智能助手所需处理的众多事务中的一种
本篇博客将着手于解决有向图的拓扑排序问题

问题描述：

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, return the ordering of courses you should take to finish all courses.
There may be multiple correct orders, you just need to return one of them. If it is impossible to finish all courses, return an empty array.

Input Sample:
4, [[1,0],[2,0],[3,1],[3,2]]
Output Sample:
[0,1,2,3] or [0,2,1,3]

这个问题看似复杂，但比对一下就能发现，如果将每节课看作是一个节点，某节课必须在另一节课的前面看作是一条有向边
那么这个问题就化为了有向图的拓扑排序问题
还需要解决的一个问题就是是否有解，想想一个有向图能够进行拓扑排序的条件是无环，否则拓扑排序根本就没有意义

模型建立起来之后，再来考虑方法，拓扑排序常见的有两种：DFS法和入度数组法

DFS法
对有向图进行DFS搜索，并记录访问每个节点前的时刻(pre值)和每个节点访问结束的时刻(post值)，按post值从大到小排序得到的即是拓扑序，若是DFS数中有回边就意味着有向图不满足无环的性质
为了避免得到post值再进行排序，实际上可以在DFS过程结束访问某个节点的时候将其放进列表，完成之后将列表倒置即可
确认是否有回边也无需等待DFS做完在判断，而是在DFS过程中就完全可以完成判断，即另开一个标志数组Onpath，在访问之前设置为true，访问之后设置为false，如果后访问的节点有指向onpath值为true节点的边，则存在回向边即有环存在

class Solution(object):
    def __init__(self):
        self.adj_list = []
    def findOrder(self, numCourses, prerequisites):
        res = []
        self.adj_list = [[] for i in range(numCourses)]
        for li in prerequisites:
            self.adj_list[li[1]].append(li[0])
        if self.dfs(res, numCourses):
            res.reverse()
            return res
        else :
            return []

    def dfs(self, res, numCourses):
        visited = [False] * numCourses
        onpath = [False] * numCourses
        for x in range(numCourses):
            if not visited[x] and not self.explore(x, res, visited, onpath):
                return False
        return True

    def explore(self, nodeNum, res, visited, onpath):
        onpath[nodeNum] = visited[nodeNum] = True
        for x in self.adj_list[nodeNum]:
            if onpath[x] or (not visited[x] and not self.explore(x, res, visited, onpath)):
                return False
        res.append(nodeNum)
        onpath[nodeNum] = False
        return True

入度数组法
理论依据(定理)：任意的有向无环图都有至少一个源顶点(入度为0)和至少一个汇顶点(出度为0)
定义产生了这样一个算法：任意找到一个源顶点放入拓扑数组，从图中删除并修改相关点的入度，直到图为空，或者找不到源顶点为止
注意寻找源顶点的技巧，可以创建一个列表来存储源顶点，修改入度的时候碰到为0的加到列表中即可

class Solution(object):
    def __init__(self):
        self.adj_list = []
    def findOrder(self, numCourses, prerequisites):
        res = []
        indegree = [0 for i in range(numCourses)]
        self.adj_list = [[] for i in range(numCourses)]
        for li in prerequisites:
            self.adj_list[li[1]].append(li[0])
            indegree[li[0]] += 1
        if self.topSort(numCourses, indegree, res):
            return res
        else :
            return []

    def topSort(self, numCourses, _indegree, res):
        indegree = _indegree.copy()
        deleted = [False for i in  range(numCourses)]
        indeg0 = []
        for i in range(numCourses):
            if indegree[i] == 0:
                indeg0.append(i)
        while numCourses:
            if len(indeg0) == 0:
                return False
            numCourses -= 1
            sourceNum = indeg0.pop(0)
            deleted[sourceNum] = True
            res.append(sourceNum)
            for x in self.adj_list[sourceNum]:
                if deleted[x]:
                    return False
                indegree[x] -= 1
                if indegree[x] == 0:
                    indeg0.append(x)
        return True