挺久没有写博客了，这几天小澈实在是太懒了，每天都在过着“萎靡”不振的时间，每天练得算法题也质量不高，学习新东西也毫无感觉与激情，学习了当没有学过一样，（多么怀念开学，然而这学期已经百分之八十的概率不开学），心里瑟瑟发抖，家里的日子太难过了呀，不过，今天开始,接下来自己会更加的有动力，立一个小小的flag——天天刷题！！！！！废话挺多的，下面直入主题吧。
简单说一下拓扑排序。
给定一个包含 n 个节点的有向图 G，我们给出它的节点编号的一种排列，如果满足：
对于图 G 中的任意一条有向边 (u, v)，u 在排列中都出现在 v 的前面。
那么称该排列是图 G 的「拓扑排序」。根据上述的定义，我们可以得出两个结论：
-
如果图G存在环(即图G不是「有向无环图),那么图 G不存在拓扑排序。这是因为假设图 中存在环x1,x2,… ,xn,x1,那么x1在排列中必须出现在xn的前面，但xn同时也必须出现在 x1的前面，因此不存在一个满足要求的排列，也就不存在拓扑排序;
-
如果图G有无环图,那么它的拓扑排序可能不止一种。举一个最极端的例子,如果图G值包含
n个节点却没有任何边,那么任意一种编号的排列都可以作为拓扑排序。
货挺干的，用一个题诠释最好不过了
现在你总共有 n 门课需要选，记为 0 到 n-1。
在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。
可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。
示例 1:
输入: 2, [[1,0]]
输出: [0,1]
解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为
[0,1] 。
示例 2:
输入: 4, [[1,0],[2,0],[3,1],[3,2]]
输出: [0,1,2,3] or [0,2,1,3]
解释: 总共有 4门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。 说明:输入的先决条件是由边缘列表表示的图形，而不是邻接矩阵。详情请参见图的表示法。 你可以假定输入的先决条件中没有重复的边。
提示:
这个问题相当于查找一个循环是否存在于有向图中。如果存在循环，则不存在拓扑排序，因此不可能选取所有课程进行学习。
拓扑排序也可以通过 BFS 完成。
方法一：拓扑排序（Kahn 算法、类似广度优先遍历的思路）
● [拓扑排序转]应用于有向图的算法;
● 这道题用BFS和DFS都可以完成，只需要掌握BFS的写法就可以了，BFS的写法很经典;
● BFS的写法就叫[拓扑排序，这里还用到了心算法的思想，贪的点是:当前让入度为0的那些结
点入队;
● [拓扑排序的结果不唯一 ;
● 删除结点的操作，通过「入度数组」体现，这个技巧要掌握;
● [拓扑排序的一个附加效果是:能够顺带检测有向图中是否存在环，这个知识点腓常重要,如果在
面试的过程中遇到这个问题，要把这一点说出来。
具有类似附加功能的算法还有: Bellman-Ford算法附加的作用是可以用于检测是否有负权环
如果优先图中，存在环，拓扑排序不能继续得到入度值为 0 的节点，退出循环，此时图中存在没有遍历到的节点，说明图中存在环。
此时说明课程设计不合理，有循环依赖。
拓扑排序实际上应用的是贪心算法，贪心算法简而言之：每一步最优，则全局最优。
具体到拓扑排序，每一次都从图中删除没有前驱的顶点，这里并不需要真正的做删除操作，我们可以设置一个入度数组，每一轮都输出入度为 0 的结点，并移除它、修改它指向的结点的入度（−1即可），依次得到的结点序列就是拓扑排序的结点序列。如果图中还有结点没有被移除，则说明“不能完成所有课程的学习”。
拓扑排序保证了每个活动（在这题中是“课程”）的所有前驱活动都排在该活动的前面，并且可以完成所有活动。拓扑排序的结果不唯一。拓扑排序还可以用于检测一个有向图是否有环。相关的概念还有 AOV 网，这里就不展开了。
算法流程：
1、在开始排序前，扫描对应的存储空间（使用邻接表），将入度为 0 的结点放入队列。
2、只要队列非空，就从队首取出入度为0 的结点，将这个结点输出到结果集中，并且将这个结点的所有邻接结点（它指向的结点）的入度减 1，在减 1 以后，如果这个被减 1 的结点的入度为 0 ，就继续入队。
3、当队列为空的时候，检查结果集中的顶点个数是否和课程数相等即可。
（思考这里为什么要使用队列？如果不用队列，还可以怎么做，会比用队列的效果差还是更好？）
在代码具体实现的时候，除了保存入度为 0 的队列，我们还需要两个辅助的数据结构：
1、邻接表：通过结点的索引，我们能够得到这个结点的后继结点；
2、入度数组：通过结点的索引，我们能够得到指向这个结点的结点个数。
这个两个数据结构在遍历题目给出的邻边以后就可以很方便地得到。
java
public int[] findOrder(int numCourses, int[][] prerequisites) {
if (numCourses <= 0) {
return new int[0];
}
@SuppressWarnings("unchecked")
HashSet<Integer>[] adj = new HashSet[numCourses];// 邻接表储存
for (int i = 0; i < numCourses; i++) {
adj[i] = new HashSet<>();
}
// [1,0] 0->1
int[] inDegree = new int[numCourses];// 记录入度
for (int[] p : prerequisites) {
adj[p[1]].add(p[0]);
inDegree[p[0]]++;
}
Queue<Integer> queue = new LinkedList<>();
for (int i = 0; i < numCourses; i++) {
if (inDegree[i] == 0) {
queue.offer(i);
}
}
int[] res = new int[numCourses];
int count = 0;
while (!queue.isEmpty()) {
// 当前入度为0的节点
Integer head = queue.poll();
res[count] = head;
count++;
Set<Integer> successors = adj[head];
for (Integer next : successors) {
inDegree[next]--;
// 马上监测给节点的入度是否为0；如果为0，马上加入队列
if (inDegree[next] == 0) {
queue.offer(next);
}
}
}
// 如果结果集中的数量不等于节点的数量，就不能完成课程任务，这一点是拓扑拍戏的结论
if (count == numCourses) {
return res;
}
return new int[0];
}
python
class Solution(object):
def findOrder(self, numCourses, prerequisites):
"""
:type numCourses: int 课程门数
:type prerequisites: List[List[int]] 课程与课程之间的关系
:rtype: bool
"""
# 课程的长度
clen = len(prerequisites)
if clen == 0:
# 没有课程，当然可以完成课程的学习
return [i for i in range(numCourses)]
# 入度数组，一开始全部为 0
in_degrees = [0 for _ in range(numCourses)]
# 邻接表
adj = [set() for _ in range(numCourses)]
# 想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
# 1 -> 0，这里要注意：不要弄反了
for second, first in prerequisites:
in_degrees[second] += 1
adj[first].add(second)
# print("in_degrees", in_degrees)
# 首先遍历一遍，把所有入度为 0 的结点加入队列
res = []
queue = []
for i in range(numCourses):
if in_degrees[i] == 0:
queue.append(i)
while queue:
top = queue.pop(0)
res.append(top)
for successor in adj[top]:
in_degrees[successor] -= 1
if in_degrees[successor] == 0:
queue.append(successor)
if len(res) != numCourses:
return []
return res
方法二: 深度优先搜索
思路
我们可以将深度优先搜索的流程与拓扑排序的求解联系起来，用一个栈来存储所有已经搜索完成的节点。
对于一个节点 u，如果它的所有相邻节点都已经搜索完成，那么在搜索回溯到 u 的时候，u 本身也会变成一个已经搜索完成的节点。这里的「相邻节点」指的是从 u 出发通过一条有向边可以到达的所有节点。
假设我们当前搜索到了节点 u，如果它的所有相邻节点都已经搜索完成，那么这些节点都已经在栈中了，此时我们就可以把 u 入栈。可以发现，如果我们从栈顶往栈底的顺序看，由于 u 处于栈顶的位置，那么 u 出现在所有 u 的相邻节点的前面。因此对于 u 这个节点而言，它是满足拓扑排序的要求的。
这样以来，我们对图进行一遍深度优先搜索。当每个节点进行回溯的时候，我们把该节点放入栈中。最终从栈顶到栈底的序列就是一种拓扑排序。
算法
对于图中的任意一个节点，它在搜索的过程中有三种状态，即：
「未搜索」：我们还没有搜索到这个节点；
「搜索中」：我们搜索过这个节点，但还没有回溯到该节点，即该节点还没有入栈，还有相邻的节点没有搜索完成）；
「已完成」：我们搜索过并且回溯过这个节点，即该节点已经入栈，并且所有该节点的相邻节点都出现在栈的更底部的位置，满足拓扑排序的要求。
通过上述的三种状态，我们就可以给出使用深度优先搜索得到拓扑排序的算法流程，在每一轮的搜索搜索开始时，我们任取一个「未搜索」的节点开始进行深度优先搜索。
我们将当前搜索的节点 u 标记为「搜索中」，遍历该节点的每一个相邻节点 v：
如果 v 为「未搜索」，那么我们开始搜索 v，待搜索完成回溯到 u；
如果 v 为「搜索中」，那么我们就找到了图中的一个环，因此是不存在拓扑排序的；
如果 v 为「已完成」，那么说明 v 已经在栈中了，而 u 还不在栈中，因此 u 无论何时入栈都不会影响到 (u, v)(u,v) 之前的拓扑关系，以及不用进行任何操作。
当 u 的所有相邻节点都为「已完成」时，我们将 u 放入栈中，并将其标记为「已完成」。
在整个深度优先搜索的过程结束后，如果我们没有找到图中的环，那么栈中存储这所有的 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
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]
方法二：深度优先遍历（写法二）
这里要使用逆邻接表。其实就是检测这个有向图中有没有环，只要存在环，这些课程就不能按要求学完。
算法流程：
第 1 步：构建逆邻接表；
第 2 步：递归处理每一个还没有被访问的结点，具体做法很简单：对于一个结点来说，先输出指向它的所有顶点，再输出自己。
第 3 步：如果这个顶点还没有被遍历过，就递归遍历它，把所有指向它的结点都输出了，再输出自己。注意：当访问一个结点的时候，应当先递归访问它的前驱结点，直至前驱结点没有前驱结点为止。
java
public int[] findOrder(int numCourses, int[][] prerequisites) {
if (numCourses <= 0) {
// 连课程数目都没有，就根本没有办法完成练习了，根据题意应该返回空数组
return new int[0];
}
int plen = prerequisites.length;
if (plen == 0) {
// 没有有向边，则表示不存在课程依赖，任务一定可以完成
int[] ret = new int[numCourses];
for (int i = 0; i < numCourses; i++) {
ret[i] = i;
}
return ret;
}
int[] marked = new int[numCourses];
// 初始化有向图 begin
HashSet<Integer>[] graph = new HashSet[numCourses];
for (int i = 0; i < numCourses; i++) {
graph[i] = new HashSet<>();
}
// 初始化有向图 end
// 有向图的 key 是前驱结点，value 是后继结点的集合
for (int[] p : prerequisites) {
graph[p[1]].add(p[0]);
}
// 使用 Stack 或者 List 记录递归的顺序，这里使用 Stack
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < numCourses; i++) {
if (dfs(i, graph, marked, stack)) {
// 注意方法的语义，如果图中存在环，表示课程任务不能完成，应该返回空数组
return new int[0];
}
}
// 在遍历的过程中，一直 dfs 都没有遇到已经重复访问的结点，就表示有向图中没有环
// 所有课程任务可以完成，应该返回 true
// 下面这个断言一定成立，这是拓扑排序告诉我们的结论
assert stack.size() == numCourses;
int[] ret = new int[numCourses];
// 想想要怎么得到结论，我们的 dfs 是一致将后继结点进行 dfs 的
// 所以压在栈底的元素，一定是那个没有后继课程的结点
// 那个没有前驱的课程，一定在栈顶，所以课程学习的顺序就应该是从栈顶到栈底
// 依次出栈就好了
for (int i = 0; i < numCourses; i++) {
ret[i] = stack.pop();
}
return ret;
}
/**
* 注意这个 dfs 方法的语义
*
* @param i 当前访问的课程结点
* @param graph
* @param marked 如果 == 1 表示正在访问中，如果 == 2 表示已经访问完了
* @return true 表示图中存在环，false 表示访问过了，不用再访问了
*/
private boolean dfs(int i,
HashSet<Integer>[] graph,
int[] marked,
Stack<Integer> stack) {
// 如果访问过了，就不用再访问了
if (marked[i] == 1) {
// 从正在访问中，到正在访问中，表示遇到了环
return true;
}
if (marked[i] == 2) {
// 表示在访问的过程中没有遇到环，这个节点访问过了
return false;
}
// 走到这里，是因为初始化呢，此时 marked[i] == 0
// 表示正在访问中
marked[i] = 1;
// 后继结点的集合
HashSet<Integer> successorNodes = graph[i];
for (Integer successor : successorNodes) {
if (dfs(successor, graph, marked, stack)) {
// 层层递归返回 true ，表示图中存在环
return true;
}
}
// i 的所有后继结点都访问完了，都没有存在环，则这个结点就可以被标记为已经访问结束
// 状态设置为 2
marked[i] = 2;
stack.add(i);
// false 表示图中不存在环
return false;
}
}
python
def findOrder(self, numCourses, prerequisites):
# 课程的长度
clen = len(prerequisites)
if clen == 0:
# 没有课程，当然可以完成课程的学习
return [i for i in range(numCourses)]
# 逆邻接表
inverse_adj = [set() for _ in range(numCourses)]
# 想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
# 1 -> 0，这里要注意：不要弄反了
for second, first in prerequisites:
inverse_adj[second].add(first)
visited = [0 for _ in range(numCourses)]
# print("in_degrees", in_degrees)
# 首先遍历一遍，把所有入度为 0 的结点加入队列
res = []
for i in range(numCourses):
if self.__dfs(i,inverse_adj, visited, res):
return []
return res
def __dfs(self, vertex, inverse_adj, visited, res):
"""
注意：这个递归方法的返回值是返回是否有环
:param vertex: 结点的索引
:param inverse_adj: 逆邻接表，记录的是当前结点的前驱结点的集合
:param visited: 记录了结点是否被访问过，2 表示当前正在 DFS 这个结点
:return: 是否有环
"""
# 2 表示这个结点正在访问
if visited[vertex] == 2:
# DFS 的时候如果遇到一样的结点，就表示图中有环，课程任务便不能完成
return True
if visited[vertex] == 1:
return False
# 表示正在访问这个结点
visited[vertex] = 2
# 递归访问前驱结点
for precursor in inverse_adj[vertex]:
# 如果没有环，就返回 False，
# 执行以后，逆拓扑序列就存在 res 中
if self.__dfs(precursor, inverse_adj, visited, res):
return True
# 能走到这里，说明所有的前驱结点都访问完了，所以可以输出了
# 并且将这个结点状态置为 1
visited[vertex] = 1
# 先把 vertex 这个结点的所有前驱结点都输出之后，再输出自己
res.append(vertex)
# 最后不要忘记返回 False 表示无环
return False
到这里，这篇文章便已经结束，总结一下：其实拓扑排序在算法中属于中等偏上的水平，我做的时候也是想不出来解题方法，便去搜寻他人的题解，还是得多练习练习，找自己的题感，加油！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
