210_课程表II

难度：中等

题目

现在你总共有 numCourses 门课需要选，记为 0 到 numCourses - 1。给你一个数组 prerequisites ，其中 prerequisites[i] = [ai, bi] ，表示在选修课程 ai 前 必须 先选修 bi 。

  • 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示：[0,1] 。

返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序，你只要返回 任意一种 就可以了。如果不可能完成所有课程，返回 一个空数组 。

示例

示例一：

输入：numCourses = 2, prerequisites = [[1,0]]
输出：[0,1]
解释：总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。

示例二：

输入：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] 。

示例三：

输入：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] 互不相同

解题

将每门课看成一个节点。如果想要学习课程 A 之前必须完成课程 B，那么从 B 到 A 连接一条有向边。

所以先构建一个有向图，用栈来存储所有已经搜索完成的节点。

在每一轮的搜索搜索开始时，任取一个「未搜索」的节点开始进行深度优先搜索：

  • 如果 v 为「未搜索」，那么我们开始搜索 v，待搜索完成回溯到 u；
  • 如果 v 为「搜索中」，那么我们就找到了图中的一个环，因此是不存在拓扑排序的；
  • 如果 v 为「已完成」，那么说明 v 已经在栈中了，而 u 还不在栈中，因此 u 无论何时入栈都不会影响到 (u, v) 之前的拓扑关系，以及不用进行任何操作。

当 u 的所有相邻节点都为「已完成」时，我们将 u 放入栈中，并将其标记为「已完成」

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
class Solution {
    // 存储有向图
    List<List<Integer>> edges;
    // 标记每个节点的状态 0：未搜索 1：搜索中 2：已完成
    int[] visited;
    // 用数组模拟栈，下标0为栈顶
    int[] result;
    // 栈下标
    int index;
    // 判断是否有环
    boolean valid = true;
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        edges = new ArrayList<List<Integer>>();
        for (int i = 0; i < numCourses; i++) {
            edges.add(new ArrayList<Integer>());
        }
        visited = new int[numCourses];
        result = new int[numCourses];
        index = numCourses-1;
        for (int[] prereq: prerequisites){
            edges.get(prereq[1]).add(prereq[0]);
        }
        // 每次挑选一个 未搜索 节点，开始深度优先搜索
        for (int i=0; i<numCourses && valid; i++){
            if (visited[i]==0){
                dfs(i);
            }
        }
        if (!valid){
            return new int[0];
        }
        // 如果没有环，那么存在排序
        return result;
    }
    void dfs(int u){
        // 将节点标记为搜索中
        visited[u] = 1;
        // 搜索相邻节点
        for (int v: edges.get(u)){
            // 如果未搜索 那么搜索相邻节点
            if (visited[v]==0){
                dfs(v);
                if (!valid) return;
            }
            // 如果搜索中 说明找到了环
            else if (visited[v]==1){
                valid = false;
                return;
            }
        }
        // 将节点标记为已完成
        visited[u] = 2;
        // 将节点入栈
        result[index--] = u;
    }
}