LeetCode 210. Course Schedule II

This is standard topological sort

1: First solution, using stack.

#include <vector>#include <stack>#include <iostream>#include <algorithm>#include <unordered_map>using namespace std;/*  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]  Another example:  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.*/// This is clearly to do toplogical sort.void toplogicalSort(unordered_map<int, vector<int> > courses, unordered_map<int, bool>& visited, stack<int>& nodes, int i) {  visited[i] = true;    vector<int> edges = courses[i];  for(int k = 0; k < edges.size(); ++k) {    if(!visited[edges[k]]) {      toplogicalSort(courses, visited, nodes, edges[k]);    }  } nodes.push(i);  // notice this line. After traversing all the nodes, push it backward.}vector<int> findOrder(int numCourses, vector<pair<int, int> >& prerequisites) {  unordered_map<int, bool> visited;  for(int i = 0; i < numCourses; ++i) {    visited[i] = false;  }  unordered_map<int, vector<int> > courses;  for(int i = 0; i < prerequisites.size(); ++i) {    int first = prerequisites[i].first;    int second = prerequisites[i].second;    courses[first].push_back(second);  }  stack<int> nodes;  for(int i = 0; i < numCourses; ++i) {    if(!visited[i]) {      toplogicalSort(courses, visited, nodes, i);    }  }  vector<int> res;  while(!nodes.empty()) {    int tmp = nodes.top();    nodes.pop();    res.push_back(tmp);  }  return res;}int main(void) {  vector< pair<int, int> > prerequisites{{1, 0}, {2, 0}, {3, 1}, {3, 2}};  vector<int> res = findOrder(4, prerequisites);  reverse(res.begin(), res.end());  for(int i = 0; i < res.size(); ++i) {    cout << res[i] << " ";  }  cout << endl;}

2: Second solution. 

First find the degree 0 vertex and apply dfs search.

class Solution {public:    vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {        if (numCourses == 0) return vector<int>(0, 0);        unordered_map<int, vector<int> > adjacentList;        vector<int> startList(numCourses, 0);        for (auto pre : prerequisites) {            adjacentList[pre.first].push_back(pre.second);            startList[pre.second]++;  // this is the graph node's degree.        }        int visitedNodes = 0;        vector<int> marks(numCourses, 0); // 0 indicates not marked, 1 temporary marked, 2 permanent marked        vector<int> orders;        while (visitedNodes < numCourses) {            //find one unvisited node with indegree == 0            int startNode = findOneUnvisitedNode(numCourses, startList, marks);            // if cannot find a startNode, return false;            if (startNode >= numCourses) return vector<int>(0, 0);            // dfs from start node            if (!dfs(startNode, adjacentList, marks, visitedNodes, orders)) return vector<int>(0, 0);        }        return orders;    }    int findOneUnvisitedNode(int numCourses, vector<int>& startList, vector<int>& marks) {        int startNode = 0;        for (; startNode < numCourses; startNode++) {            if (startList[startNode] == 0 && marks[startNode] == 0)                break;        }        return startNode;    }    bool dfs (int startNode, unordered_map<int, vector<int> >& adjacentList, vector<int>& marks, int & visitedNodes, vector<int>& orders) {        if (marks[startNode] == 1) return false;        if (marks[startNode] == 0) {            marks[startNode] = 1;            //visit all adjacent node            for (auto neighbor : adjacentList[startNode]) {                if (!dfs(neighbor, adjacentList, marks, visitedNodes, orders)) return false;            }            marks[startNode] = 2;            orders.push_back(startNode);            visitedNodes++;        }        return true;    }};

https://leetcode.com/discuss/90109/dfs-c-solution-topological-sort

https://courses.cs.washington.edu/courses/cse326/03wi/lectures/RaoLect20.pdf