课程表 II

课程表 II

题目:
现在你总共有 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] 。

解题思路: 和课程表相似, 只是将返回从布尔值变为了数组

BFS:

class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        int indegree[] = new int[numCourses];
        List<List<Integer>> list = new ArrayList();
        Queue<Integer> queue = new LinkedList();

        for(int i = 0; i < numCourses; i++) {
            list.add(new ArrayList());
        }

        for(int i = 0; i < prerequisites.length; i++) {
            indegree[prerequisites[i][0]]++;
            list.get(prerequisites[i][1]).add(prerequisites[i][0]);
        }

        for(int i = 0; i < indegree.length; i++) {
            if(indegree[i] == 0) {
                queue.offer(i);
            }
        }

        List<Integer> ans = new ArrayList();
        while(!queue.isEmpty()) {
            int cur = queue.poll();
            ans.add(cur);
            for(int e : list.get(cur)) {
                indegree[e]--;
                if(indegree[e] == 0) {
                    queue.offer(e);
                }
            }
        }

        if(ans.size() != numCourses) {
            return new int[]{};
        }

        int res[] = new int[ans.size()];
        for(int i = 0; i < ans.size(); i++) {
            res[i] = ans.get(i);
        }

        return res;
    }
}

DFS:

class Solution {

    private int[] ans;
    private int[] book;
    private boolean flag;
    private List<List<Integer>> list;
    private int idx;

    public int[] findOrder(int numCourses, int[][] prerequisites) {
        list = new ArrayList();
        ans = new int[numCourses];
        book = new int[numCourses];
        idx = numCourses - 1;	// 深度优先遍历最先进入数组的节点会是出度为9的节点

        for(int i = 0; i < numCourses; i++) {
            list.add(new ArrayList());
        }

        for(int i = 0; i < prerequisites.length; i++) {
            list.get(prerequisites[i][1]).add(prerequisites[i][0]);
        }

        for(int i = 0; i < numCourses; i++) {
            if(book[i] == 0) {
                dfs(i);
            }
            if(flag) {
                return new int[]{};
            }
        }

        if(flag) {
            return new int[]{};
        }

        return ans;
    }

    private void dfs(int cur) {
        if(book[cur] == 1) {
            flag = true;
            return ;
        }

        if(flag) {
            return ;
        }

        book[cur] = 1;
        for(int e : list.get(cur)) {
            if(book[e] == 0) {
                dfs(e);
                if(flag) {
                    return ;
                }
            } else if(book[e] == 1) {
                flag = true;
                return ;
            }
        }

        ans[idx--] = cur;
        book[cur] = -1;
    }
}