题目描述
现在你总共有 numCourses 门课需要选,记为 0 到 numCourses - 1。给你一个数组 prerequisites ,其中 prerequisites[i] = [ai, bi] ,表示在选修课程 ai 前 必须 先选修 bi 。
例如,想要学习课程 0 ,你需要先完成课程 1 ,我们用一个匹配来表示:[0,1] 。
返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序,你只要返回 任意一种 就可以了。如果不可能完成所有课程,返回 一个空数组 。
示例 1:
输入:numCourses = 2, prerequisites = [[1,0]]
输出:[0,1]
解释:总共有 2 门课程。要学习课程 1,你需要先完成课程 0。因此,正确的课程顺序为 [0,1] 。
示例 2:
输入:numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
输出:[0,2,1,3]
解释:总共有 4 门课程。要学习课程 3,你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
因此,一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。
示例 3:
输入:numCourses = 1, prerequisites = []
输出:[0]
提示:
1 <= numCourses <= 2000
0 <= prerequisites.length <= numCourses * (numCourses - 1)
prerequisites[i].length == 2
0 <= ai, bi < numCourses
ai != bi
所有[ai, bi] 互不相同
解题思路
一个典型的拓扑排序的题目,如果存在拓扑排序,返回一个拓扑排序的结果,如果不存在返回一个空数组。
方法一:DFS
用一个栈来存储所有已经搜索完成的节点。
对于一个节点 uuu,如果它的所有相邻节点都已经搜索完成,那么在搜索回溯到 uuu 的时候,uuu 本身也会变成一个已经搜索完成的节点。这里的「相邻节点」指的是从 uuu 出发通过一条有向边可以到达的所有节点。
假设我们当前搜索到了节点 uuu,如果它的所有相邻节点都已经搜索完成,那么这些节点都已经在栈中了,此时我们就可以把 uuu 入栈。可以发现,如果我们从栈顶往栈底的顺序看,由于 uuu 处于栈顶的位置,那么 uuu 出现在所有 uuu 的相邻节点的前面。因此对于 uuu 这个节点而言,它是满足拓扑排序的要求的。
这样以来,我们对图进行一遍深度优先搜索。当每个节点进行回溯的时候,我们把该节点放入栈中。最终从栈顶到栈底的序列就是一种拓扑排序。
对于图中的任意一个节点,它在搜索的过程中有三种状态,即:
-
「未搜索」:我们还没有搜索到这个节点;
-
「搜索中」:我们搜索过这个节点,但还没有回溯到该节点,即该节点还没有入栈,还有相邻的节点没有搜索完成);
-
「已完成」:我们搜索过并且回溯过这个节点,即该节点已经入栈,并且所有该节点的相邻节点都出现在栈的更底部的位置,满足拓扑排序的要求。
通过上述的三种状态,我们就可以给出使用深度优先搜索得到拓扑排序的算法流程,在每一轮的搜索搜索开始时,我们任取一个「未搜索」的节点开始进行深度优先搜索。
-
我们将当前搜索的节点 u 标记为「搜索中」,遍历该节点的每一个相邻节点 v:
-
如果 v为「未搜索」,那么我们开始搜索 v,待搜索完成回溯到 u;
-
如果 v 为「搜索中」,那么我们就找到了图中的一个环,因此是不存在拓扑排序的;
-
如果 v 为「已完成」,那么说明 v已经在栈中了,而 u 还不在栈中,因此 u 无论何时入栈都不会影响到 (u,v)之前的拓扑关系,以及不用进行任何操作。
-
-
当 u的所有相邻节点都为「已完成」时,我们将 u 放入栈中,并将其标记为「已完成」。
在整个深度优先搜索的过程结束后,如果我们没有找到图中的环,那么栈中存储这所有的 n 个节点,从栈顶到栈底的顺序即为一种拓扑排序。
方法二: 广度优先遍历
方法一的深度优先搜索是一种「逆向思维」:最先被放入栈中的节点是在拓扑排序中最后面的节点。我们也可以使用正向思维,顺序地生成拓扑排序,这种方法也更加直观。
我们考虑拓扑排序中最前面的节点,该节点一定不会有任何入边,也就是它没有任何的先修课程要求。当我们将一个节点加入答案中后,我们就可以移除它的所有出边,代表着它的相邻节点少了一门先修课程的要求。如果某个相邻节点变成了「没有任何入边的节点」,那么就代表着这门课可以开始学习了。按照这样的流程,我们不断地将没有入边的节点加入答案,直到答案中包含所有的节点(得到了一种拓扑排序)或者不存在没有入边的节点(图中包含环)。
上面的想法类似于广度优先搜索,因此我们可以将广度优先搜索的流程与拓扑排序的求解联系起来。
算法
我们使用一个队列来进行广度优先搜索。开始时,所有入度为 000 的节点都被放入队列中,它们就是可以作为拓扑排序最前面的节点,并且它们之间的相对顺序是无关紧要的。
在广度优先搜索的每一步中,我们取出队首的节点 u:
-
我们将 u 放入答案中;
-
我们移除 u 的所有出边,也就是将 u 的所有相邻节点的入度减少 1。如果某个相邻节点 v 的入度变为 0,那么我们就将 v 放入队列中。
在广度优先搜索的过程结束后。如果答案中包含了这 n 个节点,那么我们就找到了一种拓扑排序,否则说明图中存在环,也就不存在拓扑排序了。
代码
DFS
class Solution {
List<List<Integer>> edges; // 用来存储图的邻接表
int[] result; // 用来存储结果的
int[] visited; // 用来标记访问结果的 0表示未访问,1表示搜索中,2表示已完成
boolean flag = true;
int index ; // 模拟栈顶指针的
public int[] findOrder(int numCourses, int[][] prerequisites) {
// 初始化一下
edges = new ArrayList<List<Integer>>();
for(int i=0; i<numCourses; i++){
edges.add(new ArrayList<Integer>());
}
result = new int[numCourses];
visited = new int[numCourses];
index = numCourses - 1;
// 遍历每一个有序对
for(int[] i: prerequisites){
edges.get(i[1]).add(i[0]);
}
for(int i=0; i<numCourses && flag; i++){
// 开始dfs
if(visited[i] == 0){
dfs(i);
}
}
if(!flag){
return new int[0];
}else{
return result;
}
}
public void dfs(int n){
visited[n] = 1; // 标记为搜索中
for(int i: edges.get(n)){
if(visited[i] == 1){
// 有环,返回
flag = false;
return ;
}else if(visited[i] == 0){
// dfs
dfs(i);
if(!flag){ // 如果当前节点dfs结束,flag被修改成了false,直接结束
return ;
}
}
}
visited[n] = 2;
// 将节点入栈
result[index--] = n;
}
}
BFS
class Solution{
public int[] findOrder(int numCourses, int[][] prerequisites){
// 存储有向图
List<List<Integer>> edges = new ArrayList<>();
// 队列存储所有的入度为0的点
Queue<Integer> queue = new LinkedList<>();
// 存储所有的节点的度
int[] inDegree = new int[numCourses];
// 存储答案
int[] result = new int[numCourses];
int index = 0;
for(int i=0; i<numCourses ;i++){
edges.add(new ArrayList<>());
}
// 遍历所有的有序对
for(int[] i: prerequisites){
edges.get(i[1]).add(i[0]);
inDegree[i[0]]++;
}
for(int i=0; i<numCourses; i++){
if(inDegree[i] == 0){
queue.offer(i);
}
}
while(!queue.isEmpty()){
int tmp = queue.poll();
result[index++] = tmp; // 把当前遍历到的入度为0的节点加入结果
for(int v: edges.get(tmp)){ // 遍历所有邻接点
inDegree[v]--;
if(inDegree[v] == 0){
queue.offer(v);
}
}
}
if(index != numCourses){
return new int[0];
}
return result;
}
}