课程表
来源：力扣（LeetCode） 链接：leetcode.cn/problems/co…
你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。
在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。
例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。
示例 1：
输入：numCourses = 2, prerequisites = [[1,0]]
输出：true
解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。
示例 2：
输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
输出：false
解释：总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。
提示：
- 1 <= numCourses <= 105
- 0 <= prerequisites.length <= 5000
- prerequisites[i].length == 2
- 0 <= ai, bi < numCourses
- prerequisites[i] 中的所有课程对 互不相同
代码
import java.util.*;
public class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
// 构建图的邻接表表示
List<List<Integer>> adjacency = new ArrayList<>();
for (int i = 0; i < numCourses; i++) {
adjacency.add(new ArrayList<>());
}
// 统计每门课程的入度
int[] inDegrees = new int[numCourses];
for (int[] prerequisite : prerequisites) {
int course = prerequisite[0];
int prerequisiteCourse = prerequisite[1];
adjacency.get(prerequisiteCourse).add(course);
inDegrees[course]++;
}
// 使用BFS进行拓扑排序
Queue<Integer> queue = new LinkedList<>();
for (int i = 0; i < numCourses; i++) {
if (inDegrees[i] == 0) {
queue.offer(i);
}
}
int count = 0;
while (!queue.isEmpty()) {
int course = queue.poll();
count++;
for (int neighbor : adjacency.get(course)) {
inDegrees[neighbor]--;
if (inDegrees[neighbor] == 0) {
queue.offer(neighbor);
}
}
}
return count == numCourses;
}
}
思路分析
该题目可以转化为判断有向图是否存在环的问题。我们可以将每门课程看作图中的一个节点，先修关系则表示节点之间的有向边。如果课程表可以完成，那么图中不存在环，否则存在环。
代码中使用了邻接表的数据结构来表示图，并统计了每门课程的入度。然后使用BFS进行拓扑排序，从入度为0的节点开始，不断将入度减为0的节点加入队列，并将其邻接节点的入度减1。最终判断完成的课程数量是否等于总课程数，即可判断课程表是否可以完成。
课程表||
来源：力扣（LeetCode） 链接：leetcode.cn/problems/co…
现在你总共有 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] 互不相同
代码
import java.util.*;
public class Solution {
public int[] findOrder(int numCourses, int[][] prerequisites) {
// 构建图的邻接表表示
List<List<Integer>> adjacency = new ArrayList<>();
for (int i = 0; i < numCourses; i++) {
adjacency.add(new ArrayList<>());
}
// 统计每门课程的入度
int[] inDegrees = new int[numCourses];
for (int[] prerequisite : prerequisites) {
int course = prerequisite[0];
int prerequisiteCourse = prerequisite[1];
adjacency.get(prerequisiteCourse).add(course);
inDegrees[course]++;
}
// 使用BFS进行拓扑排序
Queue<Integer> queue = new LinkedList<>();
for (int i = 0; i < numCourses; i++) {
if (inDegrees[i] == 0) {
queue.offer(i);
}
}
int[] result = new int[numCourses];
int count = 0;
while (!queue.isEmpty()) {
int course = queue.poll();
result[count++] = course;
for (int neighbor : adjacency.get(course)) {
inDegrees[neighbor]--;
if (inDegrees[neighbor] == 0) {
queue.offer(neighbor);
}
}
}
if (count == numCourses) {
return result;
} else {
return new int[0];
}
}
}
思路分析
该题目同样可以看作是有向图的拓扑排序问题。我们可以将每门课程看作图中的一个节点，先修关系则表示节点之间的有向边。要求的是按照拓扑排序的顺序返回课程的学习顺序。
代码中的思路与第207题类似。首先构建图的邻接表表示，并统计每门课程的入度。然后使用BFS进行拓扑排序，从入度为0的节点开始，依次将节点加入结果数组中，并更新邻接节点的入度。最终判断完成的课程数量是否等于总课程数，如果是，则返回结果数组；否则，表示存在环，返回空数组。
