leecode-210 课程表Ⅱ（Medium）_java中怎么用二维数组输出课表-优快云博客

本文链接：https://blog.youkuaiyun.com/God_woodson/article/details/106221253

题目描述

现在你总共有 n 门课需要选，记为 0 到 n-1。
在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，
你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。
可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。

示例 1:

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

示例 2:

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

给定代码

class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
       
    }
}

分析

这就是一个典型的拓扑排序问题，给出 $n$ 个节点的有向图，为它的节点编号。

题解一

暴力破解，定义一个二维数组来记录先修关系。
二维数组arr[x][y] = 1代表x课程的先修课程是y。
然后外层循环numCourses次，内层再对二维数组进行遍历，确定当前节点是否可用。
具体逻辑写在注释里面了。

public int[] findOrder(int numCourses, int[][] prerequisites) {
    // 如果没课程，返回空数组
    // 如果只有一个课程，直接返回该课程
    if (numCourses == 0) {
        return new int[]{};
    } else if (numCourses == 1) {
        return new int[] {0};
    }
    
    // 用一个二维数组标识先修关系
    int [][] graph = new int[numCourses][numCourses];
    // 构造二维数组，graph[x][y] = 1代表x课程的先修课程是y
    for (int [] side : prerequisites)
    {
        graph[side[0]][side[1]] = 1;
    }
    // check为标记数组，标记课程是否已经被使用
    int [] check = new int[numCourses];
    for (int i = 0 ; i < numCourses ; i++) {
        check[i] = 0;
    }
    // 定义结果集、结果集的下标
    int [] result = new int[numCourses];
    int count = 0;
    // 每一次循环选一个课程装入结果集，直到全部选完
    while(count != numCourses)
    {
        // 环检测标志，默认有环
        boolean circleCheck = true;
        for (int i = 0 ; i < numCourses ; i++)
        {
            // 如果当前值已被使用
            if (check[i] == 1) {
                continue;
            }
            // 当前值没有被使用，循环检测其有无先修课程
            // 如果有，说明这个数还不能选，break
            // flag默认true -> 无先修课程
            boolean flag = true;
            for (int j = 0 ; j < numCourses ; j++)
            {
                // 如果该节点有先修课程
                if (graph[i][j] == 1) {
                    flag = false;
                    break;
                }
            }
            // 循环判断完毕后，确实无先修课程
            if (flag) {
                // 此时说明无环
                circleCheck = false;
                // 将该课程标记为已使用
                check[i] = 1;
                // 将该课程填充到结果集
                result[count++] = i;
                // 将以这个课为先修课程，的所有课程，的先修课程设为空
                // 比如课程1, 3以2(当前课)为先修课，那么这个循环将1, 3的先修课设为空
                for (int k = 0 ; k < numCourses ; k++) {
                    graph[k][i] = 0;
                }
                break;
            }
        }
        // 如果循环一圈，找不到无先修课程的课，说明成环了
        if (circleCheck) {
            return new int[]{};
        }
    }

    return result;
}

时间复杂度 $O(n^3)$ 。
外层循环 $O (n)$ ，然后内层是循环一个二维数组， $O(n^2)$ 。

空间复杂度 $O(n^2)$ 。
空间上大的开销就是一个二维数组，也就是 $O(n^2)$ 。

题解二

我们知道，拓扑排序中最前面的节点，该节点一定不会有任何入边，也就是它没有任何的先修课程要求；
当一个节点加入结果集后，我们就可以移除它的所有出边，代表着它的后序课程少了一门先修课程的要求；
如果这个节点变成了没有任何入边的节点，那么就代表着这门课可以开始学习了；

按照这样的流程，不断地将没有入边的节点加入答案，并解除相关的出边占用，直到答案中包含所有的节点（得到了一种拓扑排序）或者不存在没有入边的节点（图中包含环）；

环的判断也很容易，因为环的每个节点入度都至少为1（至少有一个节点指向它）。然而入度大于0的节点不可能进队列或结果集，所以最后结果集的数量是小于总课程数的。

代码逻辑：

定义一个ArrayList<Integer> [] relys，来存放课程间依赖关系。relys[i]代表第i号课程下所有后序课程。
定义入度数组int [] degree，来记录每个课程的入度（先修课程的数量）。
根据提供的数据，填充relys数组和degree数组。
新建一个队列Queue<Integer> queue，遍历入度数组degree，将所有入度为0的课程添加到队列queue中。
队列中最先进入的课程出队，添加到结果集中，再把这个课程的所有后序课程入度-1。如果这些后序课程入度为0了，那说明可以学了，入队。循环直到课程全部进入结果集（队列为空）。
检测结果集中的课程数目是否和总数相等，不相等则说明存在环（环中的节点入度≥1，永远无法进入队列或结果集）。

public int[] findOrder(int numCourses, int[][] prerequisites) {
    if (numCourses == 0) {
        return new int[]{};
    }

    // 定义入度数组，degree[i]代表第i号课的入度
    int [] degree = new int[numCourses];
    // 定义依赖数组，relys[i]代表i号课程的所有后续课程
    List<Integer> [] relys = new ArrayList[numCourses];
    // 初始化依赖数组
    for (int i = 0 ; i < numCourses ; i++) {
        relys[i] = new ArrayList();
    }

    // 填充依赖数组、入度数组
    for (int [] arr : prerequisites)
    {
        relys[arr[1]].add(arr[0]);
        degree[arr[0]]++;
    }

    // BFS队列
    Queue<Integer> q = new LinkedList<>();
    // 0入度的课程全部入队
    for (int i = 0 ; i < numCourses ; i++)
    {
        if (degree[i] == 0) {
            q.offer(i);
        }
    }

	// 结果集及下标
    int [] result = new int[numCourses];
    int count = 0;
    while(q.peek() != null)
    {
    	// 队尾元素出队，并赋值给结果集
        int temp = q.poll();
        result[count++] = temp;
        // 将该出队课程的后续课程入度-1，如果入度变为0直接入队
        for (int val : relys[temp])
        {
            degree[val]--;
            if (degree[val] == 0) {
                q.offer(val);
            }
        }
    }

	// 环判断
    if (count != numCourses) {
        return new int[]{};
    }

    return result;
}

时间复杂度 $O (n + m)$ 。
在relys、degree、queue初始化过程中，耗时 $O (n)$ 。
while内部总共进行了m次循环，m为边的数量，耗时 $O (m)$ 。

空间复杂度 $O (n + m)$ 。
relys数组开了 $O (m + n)$ 的空间，其他还有许多 $O (n)$ 的空间，如队列，结果集、入度数组。

题解三

DFS（深度优先搜索）解法。
它与上一个解法不同的是：

BFS通过维护入度，让每一个入度变为0的进队列，然后继续循环维护入度、进队。
DFS不需要维护入度，找到入度为0的节点后，直接深入它的所有后继节点，保证和它有关的所有后继节点都进入栈之后，它在入栈。意思就是，保证最先入栈的课程没有后继课程，最后入栈的课程没有先修课程。
环检测方式不同，BFS是检测结果集长度是否和总课程数相同，因为环内的每个课程入度 $\geq0$ ，所以它们不可能进队列，导致最后队列为空时，结果集的长度比总课程要小。DFS是通过状态标识来检测环的，如果一个环内的节点正在访问，那么继续深入一圈后，还是会回到这个节点，这时判断这个节点的状态，如果为正在访问，那就说明有环了。

它与上个解法（BFS）的相同点是：

邻接表relys构造思路相同。
入度数组degree构造思路相。

具体逻辑写注释里了。

import java.util.*;
class Solution {
    // 存放结果的栈
    private Stack<Integer> stack = new Stack<>();
    // 定义依赖数组，relys[i]代表i号课程的所有后续课程
    private List<Integer> [] relys;
    // 状态标识，-1表示已访问、0表示未访问、+1表示正在访问
    private int[] status;
    // 环检测标识
    private boolean check = true;

    public int[] findOrder(int numCourses, int[][] prerequisites) {
        if (numCourses == 0) {
            return new int[]{};
        }

        // 定义入度数组，degree[i]代表第i号课的入度
        int [] degree = new int[numCourses];
        // 初始化依赖数组
        relys = new ArrayList[numCourses];
        for (int i = 0 ; i < numCourses ; i++) {
            relys[i] = new ArrayList();
        }
        // 初始化状态数组
        status = new int[numCourses];

        // 填充依赖数组、入度数组
        for (int [] arr : prerequisites)
        {
            relys[arr[1]].add(arr[0]);
            degree[arr[0]]++;
        }

		// 遍历所有入度为0的节点
        for (int i = 0 ; i < numCourses ; i++)
        {
            if (degree[i] == 0) {
                dfs(i);
                // 如果深搜过程中出现环，在这里就能直接退出
                if (!check) {
                    return new int[]{};
                }
            }
        }

        // 如果所有节点形成一个环（入度 >= 0），那么就不会进行dfs循环
        // 因为循环条件是入度为0。
        // 就在这里做环检测
        if (stack.size() != numCourses) {
            return new int[]{};
        }

		// 将栈转化为结果集
        int[] result = new int[numCourses];
        for (int i = 0 ; !stack.empty() ; i++) {
            result[i] = stack.pop();
        }

        return result;
    }

    public void dfs(int i)
    {
        if (status[i] == 1) {
            // 如果这个节点正在访问，说明有环
            check = false;
            return;
        } else if (status[i] == -1) {
            // 如果已访问，直接过
            return;
        } else {
            // 没访问过，将这个节点状态变为正在访问
            status[i] = 1;
        }

        // 递归遍历其所有后继节点
        for (Integer rely : relys[i])
        {
            dfs(rely);
        }
        // 递归完毕后保证了后继节点都入栈，当前节点可以入栈
        stack.push(i);
        // 状态改为已访问
        status[i] = -1;
    }
}