[LeetCode#207]Course Schedule

Problem:

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.

Analysis:

reference: http://www.programcreek.com/2014/05/leetcode-course-schedule-java/ 
The idea behind this problem is not hard, we can treat it as a graph. The problem is to detect if there is a circle exist. Since the degrees of a node's out/in edges could be greatly different, We should consider clear all case.
Initial Wrong Idea:
Take advantage of Queue, we use BFS method to solve this problem through following pattern:
step 1: Scan the prerequisites matrix, to identify out the courses that does not have prerequisites. And add them into queue.
step 2: Pop a course out, and unlock all courses based on it as prerequisite, and add all of them into queue.
step 3: When the queue is empty, check the count of poped courses. to decide if all courses could be studied through certain order.

Solution:
public boolean canFinish(int numCourses, int[][] prerequisites) {
if (prerequisites == null)
throw new IllegalArgumentException("Invalid prerequisites matrix");
int m = prerequisites.length;
boolean[] used = new boolean[m];
int count = 0;

if (numCourses == 0 || m == 0)
return true;
Queue<Integer> queue = new LinkedList<Integer> ();
for (int i = 0; i < m; i++) {
boolean no_pre = true;
for (int j = 0; j < m; j++) {
no_pre = no_pre && (prerequisites[i][j] == 0);
}
if (no_pre) {
queue.offer(i);
}
}
if (queue.size() == 0) return false;
while (!queue.isEmpty()) {
int cur = queue.poll();
used[cur] = true;
count++;
unlockCourse(prerequisites, queue, cur, used);
}
return count == numCourses;
}

public void unlockCourse(int[][] prerequisites, Queue<Integer> queue, int cur, boolean[] used) {
int m = prerequisites.length;
for (int i = 0; i < m; i++) {
//search through BFS must tag the visited element
if (prerequisites[i][cur] == 1 && used[i] == false)
queue.offer(i);
}
}

The above solution is wrong for following reasons:
1. the graph is represented in edges rather than adjacency matrix.
2. a course may have more than one prerequisites!!! You can't unlock all courses for a unlocked course.
while (!queue.isEmpty()) {
int cur = queue.poll();
used[cur] = true;
count++;
unlockCourse(prerequisites, queue, cur, used);
}

A fix:
The above actually has laid a very good foundation for us to fix.
The same idea:
Use a queue for recording unlocked courses, when a course poped out from the queue, we increase the count of unlocked course.
Besides the queue, we also take advantage of a counter array, which records the left prerequisites for a course.
Only when the prerequisites count of a course equal to 0, we treat it as an unlocked course and add it into queue.

Step 1: count the prerequisites for each course.
int[] pre_counter = new int[numCourses];
int len = prerequisites.length;
for (int i = 0; i < len; i++) {
pre_counter[prerequisites[i][0]]++;
}

Step 2: put courses that have no prerequisites into the queue.
for (int i = 0; i < numCourses; i++) {
if (pre_counter[i] == 0)
queue.offer(i);
}

Step 3: unlock courses through unlocked courses.
while (!queue.isEmpty()) {
int cur = queue.poll();
count++;
for (int i = 0; i < len; i++) {
//note the logic here, must [i][1] == cur, guarantee repeately add in to queue
if (prerequisites[i][1] == cur) {
pre_counter[prerequisites[i][0]]--;
if (pre_counter[prerequisites[i][0]] == 0)
queue.offer(prerequisites[i][0]);
}
}
}
}

Logic pitfall:
I have made following logic errors, which result in infinite loop.
if (prerequisites[i][1] == cur) {
pre_counter[prerequisites[i][0]]--;
}
if (pre_counter[prerequisites[i][0]] == 0) {
queue.offer(prerequisites[i][0]);
}

The most common mistakes in using BFS is to revisit node and add it into queue again.
The mistake I have made at here is a good example.
for (int i = 0; i < len; i++) {
...
}
This would cause us to revisit pre_counter[prerequisites[i][0]] time and time, and keep on add prerequisites[i][0] into our queue. Thus we usually use a visited array to indicate that a course has alredy been unlocked and visisted. But for this problem, we can do it in a more simple way.

Fix method:
for (int i = 0; i < len; i++) {
if (prerequisites[i][1] == cur) {
pre_counter[prerequisites[i][0]]--;
if (pre_counter[prerequisites[i][0]] == 0)
queue.offer(prerequisites[i][0]);
}
}
Why it works?
First, let us assume the same cur would only be poped once before enter the loop.
for (int i = 0; i < numCourses; i++) {
if (pre_counter[i] == 0)
queue.offer(i);
}

Only for "prerequisites[i][1] == cur" and it just solved a unlock courses(we can say its the last prerequisites course). we add the course into queue.
if (pre_counter[prerequisites[i][0]] == 0)
queue.offer(prerequisites[i][0]);
Which means, only when a course was just unlocked, we add it into queue. No other times of adding an element into queue.
Note: the cur would only be poped out, since we add it only once.

Another fix method. use a visited array.
boolean[] visited = new boolean[numCourses];
while (!queue.isEmpty()) {
int cur = queue.poll();
visited[cur] = true;
count++;
for (int i = 0; i < len; i++) {
//note the logic here, must [i][1] == cur, guarantee repeately add in to queue
if (prerequisites[i][1] == cur)
pre_counter[prerequisites[i][0]]--;
if (pre_counter[prerequisites[i][0]] == 0 && visited[prerequisites[i][0]] == false)
queue.offer(prerequisites[i][0]);
}
}
Even though this this would solve infinte loop problem, but it still could exceed time when the size of courses is large.
Then reason is that: we keep on visit on all "pre_counter[prerequisites[i][0]]" no matter
if (prerequisites[i][1] == cur)
This method is rude and wrong, we should try to avoid uncessary check.

if (prerequisites[i][1] == cur) {
pre_counter[prerequisites[i][0]]--;
if (pre_counter[prerequisites[i][0]] == 0 && visited[prerequisites[i][0]] == false)
queue.offer(prerequisites[i][0]);
}

Solution:

public class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
if (prerequisites == null)
throw new IllegalArgumentException("the prerequisites matrix is not valid");
int len = prerequisites.length;
boolean[] visited = new boolean[numCourses];
if (numCourses == 0 || len == 0)
return true;
int[] pre_counter = new int[numCourses];
int count = 0;
Queue<Integer> queue = new LinkedList<Integer> ();
for (int i = 0; i < len; i++) {
pre_counter[prerequisites[i][0]]++;
}
for (int i = 0; i < numCourses; i++) {
if (pre_counter[i] == 0) {
queue.offer(i);
}
}
while (!queue.isEmpty()) {
int cur = queue.poll();
visited[cur] = true;
count++;
for (int i = 0; i < len; i++) {
//note the logic here, must [i][1] == cur, guarantee repeately add in to queue
if (prerequisites[i][1] == cur) {
pre_counter[prerequisites[i][0]]--;
if (pre_counter[prerequisites[i][0]] == 0 && visited[prerequisites[i][0]] == false)
queue.offer(prerequisites[i][0]);
}

}
}
return count == numCourses;
}
}