-
Notifications
You must be signed in to change notification settings - Fork 90
/
CourseScheduleII210.java
114 lines (105 loc) · 3.91 KB
/
CourseScheduleII210.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
/**
* 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, return
* the ordering of courses you should take to finish all courses.
*
* There may be multiple correct orders, you just need to return one of them.
* If it is impossible to finish all courses, return an empty array.
*
* 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 the correct course order is [0,1]
*
* 4, [[1,0],[2,0],[3,1],[3,2]]
* There are a total of 4 courses to take. To take course 3 you should have
* finished both courses 1 and 2. Both courses 1 and 2 should be taken after
* you finished course 0. So one correct course order is [0,1,2,3]. Another
* correct ordering is[0,2,1,3].
*
* Note:
* The input prerequisites is a graph represented by a list of edges, not
* adjacency matrices. Read more about how a graph is represented.
*
* You may assume that there are no duplicate edges in the input prerequisites.
*
* Hints:
* This problem is equivalent to finding the topological order in a directed
* graph. If a cycle exists, no topological ordering exists and therefore it
* will be impossible to take all courses.
*
* Topological Sort via DFS - A great video tutorial (21 minutes) on Coursera
* explaining the basic concepts of Topological Sort.
*
* Topological sort could also be done via BFS.
*
*/
public class CourseScheduleII210 {
public int[] findOrder(int numCourses, int[][] prerequisites) {
Set<Integer>[] graph = new Set[numCourses];
for (int[] link: prerequisites) {
int src = link[1];
int dst = link[0];
if (graph[src] == null) graph[src] = new HashSet<>();
graph[src].add(dst);
}
int[] order = new int[numCourses];
boolean[] visited = new boolean[numCourses];
int[] idx = new int[]{numCourses - 1};
for (int i=0; i<numCourses; i++) {
if (!visited[i]) {
if (!helper(graph, i, numCourses, new boolean[numCourses], visited, idx, order)) {
return new int[0];
}
}
}
return order;
}
private boolean helper(Set<Integer>[] graph, int curr, int numCourses, boolean[] path, boolean[] visited, int[] idx, int[] order) {
if (path[curr]) return false;
if (visited[curr]) return true;
visited[curr] = true;
path[curr] = true;
if (graph[curr] != null) {
for (int next: graph[curr]) {
if (!helper(graph, next, numCourses, path, visited, idx, order)) return false;
}
}
path[curr] = false;
order[idx[0]--] = curr;
return true;
}
public int[] findOrder2(int numCourses, int[][] prerequisites) {
Set<Integer>[] graph = new Set[numCourses];
int[] indegree = new int[numCourses];
for (int[] link: prerequisites) {
int src = link[1];
int dst = link[0];
indegree[dst]++;
if (graph[src] == null) graph[src] = new HashSet<>();
graph[src].add(dst);
}
Queue<Integer> q = new LinkedList<>();
for (int i=0; i<numCourses; i++) {
if (indegree[i] == 0) q.add(i);
}
if (q.isEmpty()) return new int[0];
int[] order = new int[numCourses];
int i = 0;
while (!q.isEmpty()) {
int curr = q.poll();
order[i++] = curr;
if (graph[curr] == null) continue;
for (int next: graph[curr]) {
indegree[next]--;
if (indegree[next] == 0) q.add(next);
}
}
return i == numCourses ? order : new int[0];
}
}