【问题描述】[第210 题][课程表 II][中等]
现在你总共有 n 门课需要选,记为 0 到 n-1。
在选修某些课程之前需要一些先修课程。 例如,想要学习课程 0 ,你需要先完成课程 1 ,我们用一个匹配来表示他们: [0,1]
给定课程总量以及它们的先决条件,返回你为了学完所有课程所安排的学习顺序。
可能会有多个正确的顺序,你只要返回一种就可以了。如果不可能完成所有课程,返回一个空数组。
输入: 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] 。
说明:
输入的先决条件是由边缘列表表示的图形,而不是邻接矩阵。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。
【解答思路】
1. 拓扑排序 BFS+贪心(重点)
// 方法 1 最简单的 BFS
public int[] findOrder(int numCourses, int[][] prerequisites) {
if (numCourses == 0) return new int[0];
int[] inDegrees = new int[numCourses];
// 建立入度表
for (int[] p : prerequisites) { // 对于有先修课的课程,计算有几门先修课
inDegrees[p[0]]++;
}
// 入度为0的节点队列
Queue<Integer> queue = new LinkedList<>();
for (int i = 0; i < inDegrees.length; i++) {
if (inDegrees[i] == 0) queue.offer(i);
}
int count = 0; // 记录可以学完的课程数量
int[] res = new int[numCourses]; // 可以学完的课程
// 根据提供的先修课列表,删除入度为 0 的节点
while (!queue.isEmpty()){
int curr = queue.poll();
res[count++] = curr; // 将可以学完的课程加入结果当中
for (int[] p : prerequisites) {
if (p[1] == curr){
inDegrees[p[0]]--;
if (inDegrees[p[0]] == 0) queue.offer(p[0]);
}
}
}
if (count == numCourses) return res;
return new int[0];
}
2. DFS
递归 脑子一定要清醒
时间复杂度:O(N^2) 空间复杂度:O(N)
// 方法 2:邻接矩阵 + DFS 由于用的数组,每次都要遍历,效率比较低
public int[] findOrder(int numCourses, int[][] prerequisites) {
if (numCourses == 0) return new int[0];
// 建立邻接矩阵
int[][] graph = new int[numCourses][numCourses];
for (int[] p : prerequisites) {
graph[p[1]][p[0]] = 1;
}
// 记录访问状态的数组,访问过了标记 -1,正在访问标记 1,还未访问标记 0
int[] status = new int[numCourses];
Stack<Integer> stack = new Stack<>(); // 用栈保存访问序列
for (int i = 0; i < numCourses; i++) {
if (!dfs(graph, status, i, stack)) return new int[0]; // 只要存在环就返回
}
int[] res = new int[numCourses];
for (int i = 0; i < numCourses; i++) {
res[i] = stack.pop();
}
return res;
}
private boolean dfs(int[][] graph, int[] status, int i, Stack<Integer> stack) {
if (status[i] == 1) return false; // 当前节点在此次 dfs 中正在访问,说明存在环
if (status[i] == -1) return true;
status[i] = 1;
for (int j = 0; j < graph.length; j++) {
// dfs 访问当前课程的后续课程,看是否存在环
if (graph[i][j] == 1 && !dfs(graph, status, j, stack)) return false;
}
status[i] = -1; // 标记为已访问
stack.push(i);
return true;
}
【总结】
1.拓扑排序
优化 HASHSET作为邻接矩阵
// 方法 2 升级版:用 HashSet 作为邻接矩阵,加速查找速度
public int[] findOrder(int numCourses, int[][] prerequisites) {
if (numCourses == 0) return new int[0];
// HashSet 作为邻接矩阵
HashSet<Integer>[] graph = new HashSet[numCourses];
for (int i = 0; i < numCourses; i++) {
graph[i] = new HashSet<>();
}
for (int[] p : prerequisites) {
graph[p[1]].add(p[0]);
}
int[] mark = new int[numCourses]; // 标记数组
Stack<Integer> stack = new Stack<>(); // 结果栈
for (int i = 0; i < numCourses; i++) {
if(!isCycle(graph, mark, i, stack)) return new int[0];
}
int[] res = new int[numCourses];
for (int i = 0; i < numCourses; i++) {
res[i] = stack.pop();
}
return res;
}
private boolean isCycle(HashSet<Integer>[] graph, int[] mark, int i, Stack<Integer> stack) {
if (mark[i] == -1) return true;
if (mark[i] == 1) return false;
mark[i] = 1;
for (int neighbor : graph[i]) {
if (!isCycle(graph, mark, neighbor, stack)) return false;
}
mark[i] = -1;
stack.push(i);
return true;
}
2.有向图解题思路 拓扑排序(优先) DFS
3. 遥想备战蓝桥杯 只是死记硬背 根本记不住 理解才是王道!
4.相关题目[Leetcode][第207题][JAVA][课程表][拓扑排序][DFS]
转载链接:https://leetcode-cn.com/problems/course-schedule-ii/solution/java-jian-dan-hao-li-jie-de-tuo-bu-pai-xu-by-kelly/
参考链接:https://leetcode-cn.com/problems/course-schedule-ii/solution/tuo-bu-pai-xu-shen-du-you-xian-bian-li-python-dai-/