[Leetcode]Course Schedule

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, is it possible for you to finish all courses?

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 it is possible.

2, [[1,0],[0,1]]

There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.

Note:
The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.

class Solution {
public:
    /*algorithm:bfs
        https://en.wikipedia.org/wiki/Topological_sorting
    */
    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
         queue<int>S;
         int L;
         //count in degree for each node 
         vector<int>in(numCourses,0);
         for(int i = 0;i < prerequisites.size();i++)in[prerequisites[i].first]++;
         //store in degree 0 nodes to S
         for(int i = 0;i < in.size();i++){
             if(!in[i])S.push(i);
         }
         L = S.size();
         //topological sort
         while(!S.empty()){
             int n = S.front();S.pop();
             for(int i = 0;i < prerequisites.size();i++){
                 if(prerequisites[i].second == n){
                     int m = prerequisites[i].first;
                     in[m]--;
                     if(!in[m]){
                        S.push(m);
                        L++;
                     }
                 }
             }
         }
         return L == numCourses;
    }
};

class Solution {
public:
    /*algorithm:dfs
        1)construct adjacent list for graph
        2)do dfs to detect loop
    */
    vector<vector<int> >buildAdjacetList(vector<pair<int, int>>& edges,int n){
        vector<vector<int> >result(n,vector<int>());
        //edge: v->w
        for(int i = 0;i < edges.size();i++){
            int v = edges[i].second,w = edges[i].first;
            result[v].push_back(w);
        }
        return result;
    }
    bool dfs(vector<vector<int> >&graph,int v,vector<int>&visit){
         if(visit[v] == -1)return false;
         if(visit[v] == 1)return true;
         visit[v] = -1;
         for(int i = 0;i < graph[v].size();i++)
            if(!dfs(graph,graph[v][i],visit))return false;
         visit[v] = 1;
         return true;
    }
    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
         vector<vector<int> >graph = buildAdjacetList(prerequisites,numCourses);
         //0: 1  1:<>
         vector<int>visit(numCourses,0);
         for(int i = 0;i < numCourses;i++){
            if(!dfs(graph,i,visit))return false;
         }
         return true;
    }
};