Course Schedule解题报告

https://leetcode.com/problems/course-schedule/

这道题是求图的拓扑排序。我们可以使用BFS和DFS的方法进行解决。使用BFS的方法我们首先找一个入度为0的点，将该点的入度置为-1以免重复访问。如果没有找到入度为0的点，说明有环，返回false然后将该节点的邻居的入度都减一。如果顺利结束返回true。

class Solution {
public:
    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
        if(prerequisites.size()==0) return true;
        vector<unordered_set<int> > graph=makeGraph(numCourses,prerequisites);
        vector<int> degrees=computeIndegrees(graph);
        for(int i=0;i<numCourses;i++){
            int j=0;
            for(;j<numCourses;j++){
                if(!degrees[j]) break;
            }
            if(j==numCourses) return false;
            degrees[j]=-1;
            for(int neigh:graph[j])
                degrees[neigh]--;
        }
        return true;
    }
     vector<unordered_set<int> > makeGraph(int numCourses, vector<pair<int, int>>& prerequisites){
         vector<unordered_set<int> > graph(numCourses);
         for(int i=0;i<prerequisites.size();i++){
             graph[prerequisites[i].second].insert(prerequisites[i].first);
         }
         return graph;
     }
     vector<int> computeIndegrees(vector<unordered_set<int> >& graph){
         vector<int> degrees(graph.size(),0);
         for(auto neighbors:graph){
             for(int vertex: neighbors){
                 degrees[vertex]++;
             }
         }
         return degrees;
     }
};

使用DFS的方法，我们从一个节点出发，任选他的一个邻居节点访问，然后访问邻居节点的邻居节点，以此类推。如果访问到一个已经被访问过得节点，则返回false，否则选其他的节点继续访问。直到所有节点都被访问一遍。在此我们需要两个标注，一个是已经永久访问过的标志，一个是在该次循环中访问过的标志。

class Solution {
public:
    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites){
        if(prerequisites.size()==0) return true;
        vector<unordered_set<int> > graph=makeGraph(numCourses,prerequisites);
        vector<bool> visited(numCourses,false);
        vector<bool> thispath(numCourses,false);
        for(int i=0;i<numCourses;i++){
            if(visited[i]) continue;
            if(!visit(graph,i,visited,thispath)) return false;
        }
        return true;
    }
     vector<unordered_set<int> > makeGraph(int numCourses, vector<pair<int, int>>& prerequisites){
         vector<unordered_set<int> > graph(numCourses);
         for(int i=0;i<prerequisites.size();i++){
             graph[prerequisites[i].second].insert(prerequisites[i].first);
         }
         return graph;
     }
     bool visit(vector<unordered_set<int> > &graph,int i,vector<bool> &visited,vector<bool> &thispath){
         if(thispath[i]) return false;
         if(visited[i]) return true;
         else{
             thispath[i]=true;
             for(int neigh:graph[i])
                if(!visit(graph,neigh,visited,thispath)||thispath[neigh]) return false;
            visited[i]=true;
            thispath[i]=false;
         }
         return true;
     }
};

关于拓扑排序的参考文献： https://en.wikipedia.org/wiki/Topological_sorting#Algorithms