vector<int> topologicalSort(vector<pair<int, int>>& graph, int numV){
vector<int> rslt;
vector<int> inDegree(numV, 0);
unordered_map<int, vector<int>> adjList;
unordered_set<int> visited;
for(auto e:graph){
inDegree[e.second]++;
adjList[e.first].push_back(e.second);
}
for(int k = 0; k < numV; k++){
int vertex = -1;
for(int i = 0; i < inDegree.size(); i++)
if(visited.find(i) == visited.end() && inDegree[i] == 0){
vertex = i;
break;
}
if(vertex == -1)
cout << "The graph contains a circle." << endl;
visited.insert(vertex);
rslt.push_back(vertex);
for(auto w:adjList[vertex])
inDegree[w]--;
}
return rslt;
}
vector<int> topologicalSort(vector<pair<int, int>>& graph, int numV){
vector<int> rslt;
vector<int> inDegree(numV, 0);
unordered_map<int, vector<int>> adjList;
queue<int> q;
for(auto e:graph){
inDegree[e.second]++;
adjList[e.first].push_back(e.second);
}
int vertex = -1;
for(int i = 0; i < inDegree.size(); i++)
if(inDegree[i] == 0){
vertex = i;
break;
}
q.push(vertex);
while(!q.empty()){
vertex = q.front();
q.pop();
rslt.push_back(vertex);
for(auto w:adjList[vertex])
if(--inDegree[w] == 0)
q.push(w);
}
if(rslt.size() < numV)
cout << "The graph contains a circle." << endl;
return rslt;
}
bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
Node node[numCourses];
vector<int> inDegree(numCourses, 0);
queue<int> que;
int cnt = 0;
for (auto par : prerequisites) {
inDegree[par.first]++;
node[par.second].next.push_back(par.first);
}
for (int i = 0; i < numCourses; ++i) {
if (inDegree[i] == 0) {
que.push(i);
++cnt;
}
}
while (!que.empty()) {
int iFront = que.front();
que.pop();
for (auto idx : node[iFront].next) {
if (inDegree[idx] > 0)
--inDegree[idx];
if (inDegree[idx] <= 0) {
que.push(idx);
++cnt;
}
}
}
return cnt == numCourses;
}
vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
int n = prerequisites.size();
vector<int> inDegree(numCourses, 0);
for(int i = 0; i < n; i++) {
inDegree[prerequisites[i].first]++;
}
queue<int> q;
for(int i = 0; i < numCourses; i++) {
if(inDegree[i] == 0) {
q.push(i);
}
}
vector<int> res;
while(!q.empty()) {
int c = q.front();
q.pop();
res.push_back(c);
for(int i = 0; i < n; i++) {
if(prerequisites[i].second == c) {
inDegree[prerequisites[i].first]--;
if(inDegree[prerequisites[i].first] == 0) {
q.push(prerequisites[i].first);
}
}
}
}
if(res.size() == numCourses) {
return res;
} else {
return vector<int> {};
}
}
vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
vector<vector<int>> adjacentList(numCourses);
vector<int> inDegree(numCourses);
for (auto& p : prerequisites) {
adjacentList[p.second].push_back(p.first);
++inDegree[p.first];
}
queue<int> q;
for (int i = 0; i < numCourses; ++i) {
if (inDegree[i] == 0) {
q.push(i);
}
}
vector<int> ret;
while (!q.empty()) {
int v = q.front();
q.pop();
ret.push_back(v);
for (auto t : adjacentList[v]) {
--inDegree[t];
if (inDegree[t] == 0) {
q.push(t);
}
}
}
if (ret.size() < numCourses) {
return vector<int>();
} else {
return ret;
}
}
bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
if (prerequisites.empty()) return true;
// inDegree[i] = k means courses i has k prerequisites
// courses without any prerequisites can be taken immedinately
vector<int> inDegree(numCourses, 0);
for (int i = 0; i < prerequisites.size(); i++) {
inDegree[prerequisites[i].first]++;
}
queue<int> prereqCourses;
int totalDegree = 0;
for (int i = 0; i < numCourses; i++) {
totalDegree += inDegree[i];
if (inDegree[i] == 0) {
prereqCourses.push(i);
}
}
if (prereqCourses.empty()) return false;
while (!prereqCourses.empty()) {
int curCourse = prereqCourses.front();
prereqCourses.pop();
for (int i = 0; i < prerequisites.size(); i++) {
if (prerequisites[i].second == curCourse) {
--totalDegree;
if (--inDegree[prerequisites[i].first] == 0) {
prereqCourses.push(prerequisites[i].first);
}
}
}
}
return totalDegree == 0;
}
bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
// lists store the edges
// each list store the connected node. <- (to nodes)
vector<vector<int>> graph(numCourses, vector<int>(0));
vector<int> inDegree(numCourses, 0);
for (auto& ele : prerequisites) {
graph[ele.second].push_back(ele.first);
inDegree[ele.first]++;
}
queue<int> que;
for (int i = 0; i < numCourses; i++) {
if (inDegree[i] == 0) {
que.push(i);
}
}
while (!que.empty()) {
int cur = que.front();
que.pop();
for (auto ele : graph[cur]) {
inDegree[ele]--;
if (inDegree[ele] == 0) {
que.push(ele);
}
}
}
// 如里最后还有入度不为0的节点的话，说明有环，否则无环。
for (int i = 0; i < numCourses; i++) {
if (inDegree[i] != 0) {
return false;
}
}
// we can also use the sort result's size()
// if it is less than numCourses, return true;
return true;
}
vector<int> findOrder(int numCourses, vector<pair<int, int> >& prerequisites) {
vector<vector<int> > graph(numCourses, vector<int>());
vector<int> inDegree(numCourses, 0);
for (auto i : prerequisites) {
graph[i.second].push_back(i.first);
++inDegree[i.first];
}
queue<int> q;
for (int i = 0; i < numCourses; ++i) {
if (inDegree[i] == 0) {
q.push(i);
}
}
vector<int> res;
while (!q.empty()) {
int node = q.front();
q.pop();
res.push_back(node);
for (auto i : graph[node]) {
--inDegree[i];
if (inDegree[i] == 0) {
q.push(i);
}
}
}
if (res.size() != numCourses) {
res.clear();
}
return res;
}
vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
vector<int> order;
if (prerequisites.empty()) {
for (int i = 0; i < numCourses; i++) {
order.push_back(i);
}
return order;
}
// construct in-degree table
vector<int> inDegree(numCourses, 0);
for (int i = 0; i < prerequisites.size(); i++) {
inDegree[prerequisites[i].first]++;
}
int totalDegree = 0;
queue<int> prereqCourses;
for (int i = 0; i < numCourses; i++) {
totalDegree += inDegree[i];
if (inDegree[i] == 0) {
prereqCourses.push(i);
}
}
if (prereqCourses.empty()) {
return order;
}
while (!prereqCourses.empty()) {
int curCourse = prereqCourses.front();
order.push_back(curCourse);
prereqCourses.pop();
for (int i = 0; i < prerequisites.size(); i++) {
if (prerequisites[i].second == curCourse) {
totalDegree--;
if (--inDegree[prerequisites[i].first] == 0) {
prereqCourses.push(prerequisites[i].first);
}
}
}
}
if (totalDegree != 0) {
order.clear();
return order;
}
return order;
}
vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
vector<int> vec;
if (numCourses <= 0){
return vec;
}
vector<set<int> > Graph(numCourses);
for (int i = 0; i < prerequisites.size(); ++i){
Graph[prerequisites[i].second].insert(prerequisites[i].first);
}
vector<int> inDegree(numCourses);
for (int i = 0; i < Graph.size(); ++i){
for (auto it = Graph[i].begin(); it != Graph[i].end();++it){
inDegree[*it]++;
}
}
queue<int> q1;
for (int i = 0; i < inDegree.size(); ++i){
if (!inDegree[i]){
q1.push(i);
}
}
while (!q1.empty()){
int value = q1.front();
vec.push_back(value);
q1.pop();
for (auto it = Graph[value].begin(); it != Graph[value].end(); ++it){
if (!--inDegree[*it]){
q1.push(*it);
}
}
}
for (int i = 0; i < numCourses; ++i){
if (inDegree[i]){
vec.clear();
return vec;
}
}
return vec;
}
vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
Node node[numCourses];
vector<int> inDegree(numCourses, 0);
vector<int> ans;
int cnt = 0;
for (auto pir : prerequisites) {
++inDegree[pir.first];
node[pir.second].next.push_back(pir.first);
}
for (int i = 0; i < numCourses; ++i) {
if (inDegree[i] == 0) {
++cnt;
ans.push_back(i);
dfs(node, inDegree, ans, cnt, i);
}
}
if (cnt != numCourses) {
ans.clear();
}
return ans;
}
