课程表

你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。

  • 例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。

请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

示例 1：

1
2
3
输入：numCourses = 2, prerequisites = [[1,0]]
输出：true
解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。

示例 2：

1
2
3
输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
输出：false
解释：总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。

提示：

  • 1 <= numCourses <= 2000
  • 0 <= prerequisites.length <= 5000
  • prerequisites[i].length == 2
  • 0 <= ai, bi < numCourses
  • prerequisites[i] 中的所有课程对 互不相同

如果课程构成的有向图存在环，就不能完成学习。可以使用拓扑排序来解决。

拓扑排序的方法：

将入度为0的点入队，每次循环将入度为0的点出队，并将其指向的点的入度减一。

当队列为空时，判断出队节点的次数是否等于总节点个数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        // 需要一个数组记录每个点的入度个数
        int[] indegrees = new int[numCourses];
        // 需要一个二维数组作为临界矩阵
        List<List<Integer>> g = new ArrayList<>();
        for (int i = 0; i < numCourses; i++) {
            g.add(new ArrayList<>());
        }
        // 初始化入度表和临界矩阵
        for (int[] p : prerequisites) {
            int course = p[0];
            int pre = p[1];
            g.get(pre).add(course);
            indegrees[course]++;
        }
        int[] queue = new int[numCourses];
        int l = 0;
        int r = 0;
        for (int i = 0; i < numCourses; i++) {
            if (indegrees[i] == 0) {
                queue[r++] = i;
            }
        }
        int count = 0;
        while (l < r) {
            int cur = queue[l++];
            count++;
            for (int i : g.get(cur)) {
                if (--indegrees[i] == 0) {
                    queue[r++] = i;
                }
            }
        }
        return count == numCourses;
    }
}