[Leetcode] Course Schedule

There are a total of n courses you have to take, labeled from 0 to n - 1.

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]

Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?

For example:

2, [[1,0]]

There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.

2, [[1,0],[0,1]]

There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.

Note:
The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.

click to show more hints.

Hints:

1. This problem is equivalent to finding if a cycle exists in a directed graph. If a cycle exists, no topological ordering exists and therefore it will be impossible to take all courses.
2. Topological Sort via DFS - A great video tutorial (21 minutes) on Coursera explaining the basic concepts of Topological Sort.
3. Topological sort could also be done via BFS.

------------------------------------------------------------------------------

BFS: 先扫一遍数组，找到没有prerequisites的课程，加入到queue里 （没有prerequisites的课程就是我们可以完成的课程）。

在来对queue里的数进行处理，知道找到所有可以完成的课程。 比较其与numCourses的大小。

public class Solution {
    // BFS VERSION
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        int[] pCounter = new int[numCourses];
        for(int[] temp: prerequisites) {
            pCounter[temp[0]]++;
        }
        Queue<Integer> noPre = new LinkedList<Integer>();
        for(int i = 0; i < pCounter.length; ++i) {
            if(pCounter[i] == 0)
                noPre.offer(i);
        }
        int res = noPre.size();
        while(!noPre.isEmpty()) {
            int cur = noPre.poll();
            for(int[] temp: prerequisites) {
                if(temp[1] == cur) {
                    pCounter[temp[0]]--;
                    if(pCounter[temp[0]] == 0) {
                        noPre.add(temp[0]);
                        res++;
                    }
                }
            }
        }
        return res == numCourses;
    }
}

DFS:

与BFS去找没有pre－node的节点方法不同，DFS是利用：这个点作为prerequisite，我接下来可以选择哪些node来处理的。

在这里，我们需要用一个boolean的数组来判断这个node我们之前有没有访问过，如果访问过了，说明有cycle。

// DFS VERSION
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        ArrayList[] nodes = new ArrayList[numCourses];
        for(int i = 0; i < numCourses; ++i) {
            nodes[i] = new ArrayList<Integer>();
        }
        for(int[] temp: prerequisites) {
            nodes[temp[1]].add(temp[0]);
        }
        boolean[] visited = new boolean[numCourses];
        for(int i = 0; i < numCourses; ++i) {
            if(!canFinish(nodes, visited ,i))
                return false;
        }
        return true;
    }
    public boolean canFinish(ArrayList[] nodes, boolean[] visited, int curIndex) {
        if(visited[curIndex])
            return false;
        visited[curIndex] = true;
        ArrayList<Integer> curNeighbors = nodes[curIndex];
        for(int next: curNeighbors) {
            if(!canFinish(nodes, visited, next))
                return false;
        }
        visited[curIndex] = false;
        return true;
    }