[LeetCode] Course Schedule

现在你总共有 n 门课需要选，记为 0 到 n-1。

在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]

给定课程总量以及它们的先决条件，判断是否可能完成所有课程的学习？

示例 1:

输入: 2, [[1,0]]
输出: true
解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。
示例 2:

输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。

这个问题相当于查找一个环是否存在于有向图中。如果存在环，则不存在拓扑排序，因此不可能选取所有课程进行学习。常用的Topological Sorting算法有两种
Kahn’s Algorithms (wiki)： BFS based， start from with vertices with 0 incoming edge，insert them into list S，at the same time we remove all their outgoing edges，after that find new vertices with 0 incoming edges and go on.
Tarjan’s Algorithms (wiki)： DFS based， loop through each node of the graph in an arbitrary order，initiating a depth-first search that terminates when it hits any node that has already been visited since the beginning of the topological sort or the node has no outgoing edges (i.e. a leaf node).

BFS：
使用队列，使用一个数组记录所有节点的入度，首先将所有入度为0的节点入队，依次将节点出队，同时删除与节点相连的边，即把边的另一节点的入度减一，如果减到0了就入队，直到队空，这样出队的顺序就是拓扑排序，如果出队的节点个数不等于总结点个数说明有环。

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        List<Integer> res = new ArrayList<Integer>();
        Queue<Integer> q = new LinkedList<Integer>();
        int[] indegree = new int[numCourses];
        for (int i = 0; i < numCourses; i++)
            indegree[i] = 0;
        for (int i = 0; i < prerequisites.length; i++) {
            indegree[prerequisites[i][0]]++;
        }
        for (int i = 0; i < numCourses; i++) {
            if (indegree[i] == 0)
                q.offer(i);
        }
        while (!q.isEmpty()) {
            int source = q.poll();
            res.add(source);
            for (int[] edge:prerequisites) {
                if (edge[1] == source) {
                    indegree[edge[0]]--;
                    if (indegree[edge[0]] == 0)
                        q.offer(edge[0]);
                }                                    
            }
        }
        return res.size() == numCourses;
    }
}

DFS
使用isvisiting数组记录在进行一条路径的dfs时的访问情况，如果访问节点已经被访问过的，说明路径里存在环。stack里的节点依次出栈得到即为拓扑排序。

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        Stack<Integer> stack = new Stack<>();
        boolean[] visited = new boolean[numCourses];
        boolean[] isvisiting = new boolean[numCourses];
        for (int i = 0; i < numCourses; i++) {
            if (!dfs(i, prerequisites, visited, isvisiting, stack))
                return false;
        }
        return true;
    }
    private boolean dfs(int i, int[][] prerequisites, boolean[] visited, boolean[] isvisiting, Stack<Integer> stack) {
        if (visited[i])
            return true;
        visited[i] = true;
        isvisiting[i] = true;
        for (int j = 0; j < prerequisites.length; j++) {
            if (prerequisites[j][1] == i) {
                if (!visited[prerequisites[j][0]]) {                    
                    if (!dfs(prerequisites[j][0], prerequisites, visited, isvisiting, stack))
                        return false;
                }
                if (isvisiting[prerequisites[j][0]])
                        return false;
                    
            }
        }
        isvisiting[i] = false;
        stack.push(i);
        return true;
    }
}

以上方法的时间复杂度均为O(VE),如果用将图转化为邻接矩阵的形式，则可以将时间复杂度降低至 O(V+E)