Course Schedule

1，题目要求

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?

Example 1:
Input: 2, [[1,0]]
Output: true
Explanation: There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.

Example 2:
Input: 2, [[1,0],[0,1]]
Output: false
Explanation: 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:

1. The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.
2. You may assume that there are no duplicate edges in the input prerequisites.

您必须参加总共n门课程，标记为0到n-1。

有些课程可能有先决条件，例如，要修课程0，你必须先修课程1，表示为一对：[0,1]

鉴于课程总数和先决条件成对列表，您是否可以完成所有课程？

注意：

1. 输入先决条件是由边缘列表而不是邻接矩阵表示的图形。 详细了解图表的表示方式。
2. 您可以假设输入先决条件中没有重复的边缘。

2，题目思路

对于这道题，题目是给定一系列的二元对，second是first的先决条件，判断一些列的二元对是否构成可行的逻辑关系。

这道题看上去像是一个活动安排问题，但是实际上可以转化为一个图的问题。
即每一个二元对都可以组成一个有向对，最后可以构成一个有向图，于是问题就转化为判断一个有向图中是否有环。

对于图的遍历，一般有两种方法：

• BFS
• DFS

对于BFS的方法，我们首先需要构建出一个有向图，对于二元对[i, j]，因为j是i的先决条件，因此我们构建有向图使得j指向i。
之后，我们计算每一个顶点的入度。然后我们在图中寻找图中入度为0的顶点。

• 如果一个图中没有入度为0的顶点，说明这个图中存在环，我们返回false；
• 否则，我们将这个入度为0的顶点的入度设置为-1防止再次访问它，并将它的邻居的入度都减少1。几何含义是将这个顶点从图中删除。

当我们重复numCourses次之后，就可以得到最终的结果了。

对于DFS的方法，我们在访问时会从其中一个节点出发，然后不断的深入访问，如果我们返回到了我们当前路径中已经访问过的节点，就说明图是存在环的。
否则，我们就从另外一个尚未访问过的几点出发，并重复这个过程。

3，代码实现

1，BFS

int x = []() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    return 0;
}();

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        Graph G = buildGraph(numCourses, prerequisites);
        vector<int> degree = calIndegree(G);
        
        for(int i = 0;i<numCourses;i++){
            int j = 0;
            while(j<numCourses){
                if(degree[j] == 0)  //找到入度为0的点
                    break;
                j++;
            }
            if(j == numCourses) //没找到入度为0的点，说明图中有环
                return false;
            //因为degree[j]此时为0，所以--使得j的入度为-1
            //类似于将节点j从图中删除
            degree[j]--;    
            for(auto adj : G[j])
                degree[adj]--;  //因为我们“将节点j从图中删除”，因此将节点j相邻的节点的入度都减一
        }
        return true;
        
    }
private:
    typedef vector<vector<int>> Graph;  //定义一个有向图
    
    Graph buildGraph(int numCourses, vector<vector<int>>& prerequisites){
        Graph G(numCourses);
        //构建有向图，其中second指向first
        for(auto p : prerequisites)
            G[p[1]].push_back(p[0]);
        return G;
    }
    
    //计算每个节点的入度
    vector<int> calIndegree(Graph& G){
        vector<int> degree(G.size(), 0);
        for(auto v : G)
            for(auto adj : v)
                degree[adj]++;
        return degree;
    }
};

2，BFS的简化，原理相同

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        vector<vector<int>> adj (numCourses, vector<int> ());
        vector<int> degree(numCourses, 0);
        
        for(auto &p : prerequisites){
            adj[p[1]].push_back(p[0]);
            degree[p[0]]++;
        }
        
        queue<int> q;
        for(int i = 0;i<numCourses;i++)
            if(degree[i] == 0)  //找到所有度为0的点
                q.push(i);
        
        while(!q.empty()){
            int curr = q.front();
            q.pop();
            numCourses--;
            for(auto next : adj[curr])
                if(--degree[next] == 0)
                    q.push(next);
        }
        return numCourses == 0;
    }
};

3，DFS

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        Graph G = buildGraph(numCourses, prerequisites);
        vector<bool> toVisit (numCourses, false);
        vector<bool> visited (numCourses, false);
        
        for(int i = 0;i < numCourses;i++)
            //对visited[i]进行判断，是为了减少迭代的次数
            if(!visited[i] && !isDAG(G, toVisit, visited, i))
                return false;
        return true;
    }
    
private:
    typedef vector<vector<int>> Graph;  //定义一个有向图
    
    Graph buildGraph(int numCourses, vector<vector<int>>& prerequisites){
        Graph G(numCourses);
        //构建有向图，其中second指向first
        for(auto p : prerequisites)
            G[p[1]].push_back(p[0]);
        return G;
    }
    
    //判断一个图是否是有向无环图，是返回true，不是返回false
    //其中，DAG是有向无环图的意思
    bool isDAG(Graph &G, vector<bool>& toVisit, vector<bool>& visited, int v){
        //如果当前从一个节点出发的探测中，
        //发现了这一轮探测中才标记的节点为true
        //说明这条“路径”的探索上，回到了当前路径走过的点
        //因此，直接返回false，说明该图一定有环
        if(toVisit[v])
            return false;
        
        //如果这个节点是之前其他的路径探索中已经探索过的
        //说明从v出发的路径也一定没有环，否则程序已经以false为返回值结束了
        //而且前面的toVisit也已经对是否不是DAG有了一个判断
        //因此，这里我们直接返回true，说明该图是DAG
        if(visited[v])
            return true;
        
        toVisit[v] = true;
        visited[v] = true;
        
        for(int next : G[v])
            if(!isDAG(G, toVisit, visited, next))
                return false;
        
        //如果运行到这里，也说明了当前的判断是DAG
        //因此，为了之后从其他节点开始的路径的判断
        //我们需要将toVisit恢复
        toVisit[v] = false;
        return true;
    }
    
};