【图】拓扑排序（DFS和BFS解法）

拓扑排序

LeetCode题目：210. Course Schedule II
题目链接：https://leetcode.com/problems/course-schedule-ii/description/

题目大意：

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

来源：力扣（LeetCode）
中文翻译链接：https://leetcode-cn.com/problems/course-schedule-ii

解法分析

BFS

        BFS解法一般借助于队列实现，把入度为0的节点放入队列，把这个点加入到结果集中，然后把该节点指向的下一个节点入度减一，然后继续寻找入度为0的节点。
        拓展：给定每个节点的作业时间，求出平均等待时间最短的拓扑顺序。在拓扑排序的基础上，从队列取的时候，拿作业时间最短的点——用PriorityQueue实现，把Queue换成PriorityQueue。

public int[] findOrder(int numCourses, int[][] prerequisites) {
        // 用于存放每个节点后面的节点
        List<Integer>[] afterStudy = new List[numCourses];
        // 每个节点的入度
        int[] cnt = new int[numCourses];
        for (int i = 0; i < numCourses; i++) {
            afterStudy[i] = new ArrayList<>();
        }
        // 遍历加入该节点相邻的后面节点
        for (int[] prerequisite : prerequisites) {
            int after = prerequisite[0];
            int before = prerequisite[1];
            afterStudy[before].add(after);
            cnt[after]++;
        }
        Queue<Integer> queue = new LinkedList<>();
        // 加入初始入度为0的点
        for (int i = 0; i < cnt.length; i++) {
            if (cnt[i] == 0) {
                queue.offer(i);
            }
        }
        // 结果集
        int[] res = new int[numCourses];
        // 结果集指针
        int index = 0;
        while (!queue.isEmpty()) {
            int course = queue.poll();
            res[index++] = course;
            for (int afterCourse : afterStudy[course]) {
                cnt[afterCourse]--;
                if (cnt[afterCourse] == 0) {
                    queue.offer(afterCourse);
                }
            }
        }
        // 说明有环
        if (numCourses != index) {
            return new int[0];
        }
        return res;
    }

DFS

public int[] findOrderDFS(int numCourses, int[][] prerequisites) {
        // 相邻的后续节点
        List<Integer>[] afterStudy = new List[numCourses];
        for (int i = 0; i < numCourses; i++) {
            afterStudy[i] = new ArrayList<>();
        }
        for (int[] prerequisite : prerequisites) {
            int after = prerequisite[0];
            int before = prerequisite[1];
            afterStudy[before].add(after);
        }
        // 全局
        boolean[] globalVisited = new boolean[numCourses];
        // 局部访问
        boolean[] localVisited = new boolean[numCourses];
        Stack<Integer> res = new Stack<>();
        for (int i = 0; i < numCourses; i++) {
            // 有环则直接返回
            if (hasCycle(globalVisited, localVisited, res, i, afterStudy)) {
                return new int[0];
            }
        }
        int[] array = new int[numCourses];
        for (int i = 0; i < numCourses; i++) {
            array[i] = res.pop();
        }
        return array;
    }

    private boolean hasCycle(boolean[] globalVisited, boolean[] localVisited,
                             Stack<Integer> res, int index, List<Integer>[] afterStudy) {
        // 顺序不能变，先局部
        if (localVisited[index]) {
            return true;
        }
        if (globalVisited[index]) {
            return false;
        }
        localVisited[index] = true;
        globalVisited[index] = true;
        for (int next : afterStudy[index]) {
            if (hasCycle(globalVisited, localVisited, res, next, afterStudy)) {
                return true;
            }
        }
        localVisited[index] = false;
        res.push(index);
        return false;
    }