-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathCourseScheduleII.cc
More file actions
114 lines (95 loc) · 2.98 KB
/
Copy pathCourseScheduleII.cc
File metadata and controls
114 lines (95 loc) · 2.98 KB
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
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <limits.h>
#include <math.h>
#include <memory.h>
#include <sstream>
#include <iostream>
#include <vector>
#include <queue>
#include <list>
using namespace std;
/*
210. Course Schedule II My Submissions Question
Total Accepted: 16850 Total Submissions: 82151 Difficulty: Medium
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].
*/
class Solution {
public:
vector<int> findOrder(int numCourses, vector<pair<int, int> >& prerequisites) {
vector<list<int> > adj(numCourses, list<int>());
vector<bool> visited(numCourses, false);
vector<bool> onstack(numCourses, false);
vector<int> order;
for (auto& it : prerequisites) {
adj[it.second].push_back(it.first);
}
for (int i = 0; i < numCourses; ++i) {
if (visited[i]) continue;
if (hasCycle(adj, i, visited, onstack, order)) return vector<int>();
}
return order;
}
bool hasCycle(vector<list<int> >& adj, int v, vector<bool>& visited,
vector<bool>& onstack, vector<int>& order) {
visited[v] = true;
onstack[v] = true;
for (auto& it : adj[v]) {
if (!visited[it] && hasCycle(adj, it, visited, onstack, order))
return true;
if (onstack[it]) return true;
}
order.insert(order.begin(), v);
onstack[v] = false;
return false;
}
};
namespace solution_queue {
vector<int> findOrder(int numCourses, vector<pair<int, int> >& prerequisites) {
vector<list<int> > adj(numCourses, list<int>());
vector<int> requisites(numCourses, 0);
vector<int> order(numCourses, 0);
queue<int> que;
for (auto& it : prerequisites) {
adj[it.second].push_back(it.first);
requisites[it.first]++;
}
for (int i = 0; i < numCourses; i++) {
if (requisites[i] == 0) {
que.push(i);
}
}
int len = 0;
while (!que.empty()) {
int course = que.front();
que.pop();
order[len++] = course;
for (auto& it : adj[course]) {
if (!--requisites[it]) {
que.push(it);
}
}
}
return len == numCourses ? order : vector<int>();
}
}
int main(int argc, char const* argv[]) {
/* code */
return 0;
}