LeetCode210.课程表II

https://leetcode.cn/problems/course-schedule-ii/description/?envType=study-plan-v2&envId=top-interview-150

题目描述

现在你总共有 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;
    }
}