Course Schedule

DFS without HashMap

public class Solution {
class DiGraph{
int V;
List<Integer>[] adj;
public DiGraph(int v) {
V = v;
adj = new List[v];
for (int i = 0; i < V; i++) {
adj[i] = new ArrayList<Integer>();
}
}
public void addEdge (int u, int w) {
adj[u].add(w);
}
}

public boolean canFinish(int numCourses, int[][] prerequisites) {
DiGraph g = new DiGraph(numCourses);

for (int[] courses : prerequisites) {
g.addEdge(courses[1], courses[0]);
}

boolean[] onStack = new boolean[numCourses];

for (int i = 0; i < numCourses; i++) {
if (!dfs(g, onStack, i)) {
return false;
}
}
return true;
}

private boolean dfs(DiGraph g, boolean[] onStack, int v) {
onStack[v] = true;

for (int w : g.adj[v]) {
if (onStack[w] || !dfs(g, onStack, w)) {
return false;
}
}

onStack[v] = false;

return true;
}
}DFS with HashMap
Solution 1:(debug)

public class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
if (prerequisites == null) {
return false;
}

int length = prerequisites.length;

if (numCourses == 0 || length == 0) {
return true;
}

boolean[] onStack = new boolean[numCourses];
boolean[] visited = new boolean[numCourses];

Map<Integer, List<Integer>> map = new HashMap<Integer, List<Integer>>();

for (int[] courses : prerequisites) {
if (map.containsKey(courses[1])) {
map.get(courses[1]).add(courses[0]);
} else {
List<Integer> temp = new ArrayList<Integer>();
temp.add(courses[0]);
map.put(courses[1], temp);
}
}

for (int i = 0; i < numCourses; i++) {
if (!dfs(map, onStack, i)) {
return false;
}
}

return true;
}

private boolean dfs(Map<Integer, List<Integer>> map, boolean[] onStack, int i) {
if (visited[i] == true) {
return true;
}

onStack[i] = true;

if (map.containsKey(i)) {
for (int v : map.get(i)) {
if (onStack[v] || !dfs(map, onStack, v)) {
return false;
}
}
}

onStack[i] = false;
visited[i] = true;

return true;
}
}Solution 2: 利用剪枝，缩短DFS计算时间

public class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
if (prerequisites == null) {
return false;
}

int length = prerequisites.length;

if (numCourses == 0 || length == 0) {
return true;
}

int[] visited = new int[numCourses];

Map<Integer, List<Integer>> map = new HashMap<Integer, List<Integer>>();
for (int[] courses : prerequisites) {
if (map.containsKey(courses[1])) {
map.get(courses[1]).add(courses[0]);
} else {
List<Integer> temp = new ArrayList<Integer>();
temp.add(courses[0]);
map.put(courses[1], temp);
}
}

for (int i = 0; i < numCourses; i++) {
if (!dfs(map, visited, i)) {
return false;
}
}

return true;
}

private boolean dfs(Map<Integer, List<Integer>> map, int[] visited, int i) {
if (visited[i] == -1) {//剪枝
return false;
}

if (visited[i] == 1) {//剪枝
return true;
}
//visited[i] 默认为 0， 表示尚未访问，且不清楚是否有Cycle。
visited[i] = -1;//正在访问

if (map.containsKey(i)) {
for (int v : map.get(i)) {
if (!dfs(map, visited, v)) {
return false;
}
}
}

visited[i] = 1;//访问结束，且不出现Cycle

return true;
}
}

BFS without HashMap

public class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
if (prerequisites == null) {
return false;
}

int length = prerequisites.length;

if (numCourses == 0 || length == 0) {
return true;
}

int[] preCount = new int[numCourses];
for (int i = 0; i < length; i++) {
preCount[prerequisites[i][0]]++;
}

Queue<Integer> q = new LinkedList<Integer>();
for (int i = 0; i < numCourses; i++) {
if (preCount[i] == 0) {
q.offer(i);
}
}
int numNoPre = q.size();

while (!q.isEmpty()) {
int course = q.poll();
for (int i = 0; i < length; i++) {
if (prerequisites[i][1] == course) {
preCount[prerequisites[i][0]]--;
if (preCount[prerequisites[i][0]] == 0) {
numNoPre++;
q.offer(prerequisites[i][0]);
}
}
}
}

return numNoPre == numCourses;
}
}BFS with HashMap

public class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
if (prerequisites == null) {
return false;
}

int length = prerequisites.length;

if (numCourses == 0 || length == 0) {
return true;
}

Map<Integer, List<Integer>> map = new HashMap<Integer, List<Integer>>();
for (int[] courses : prerequisites) {
if (map.containsKey(courses[1])) {
map.get(courses[1]).add(courses[0]);
} else {
List<Integer> temp = new ArrayList<Integer>();
temp.add(courses[0]);
map.put(courses[1], temp);
}
}

int[] preCount = new int[numCourses];
for (int i = 0; i < length; i++) {
preCount[prerequisites[i][0]]++;
}

Queue<Integer> q = new LinkedList<Integer>();
for (int i = 0; i < numCourses; i++) {
if (preCount[i] == 0) {
q.offer(i);
}
}

int numNoPre = q.size();

while (!q.isEmpty()) {
int course = q.poll();
List<Integer> list = map.get(course);
if (list == null) {//最后一门课程，没有后续课程
continue;
}
for (int i : list) {
preCount[i]--;
if (preCount[i] == 0) {
numNoPre++;
q.offer(i);
}
}
}

return numNoPre == numCourses;
}
}