LeetCode 207.课程表（拓扑排序）

力扣链接LeetCode

1、 题目：

你这个学期必须选修 numCourse 门课程，记为 0 到 numCourse-1 。
在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们：[0,1]
给定课程总量以及它们的先决条件，请你判断是否可能完成所有课程的学习？
测试用例：

示例1：输入: 2, [[1,0]] 
输出: true
解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。
示例2：输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的

2、分析

这是一个有向图，能完成所有课程的学习得要求有向图中无环。图表示分为顺序存储（邻接矩阵）和链式存储（邻接表）。这里选择链式存储，邻接表

3、思路

通过拓扑排序判断此课程安排图是否是有向无环图。
拓扑排序原理： 对 DAG 的顶点进行排序，使得对每一条有向边 (u,v)，均有 u（在排序记录中）比 v先出现。亦可理解为对某点 v而言，只有当 v的所有源点均出现了，v才能出现。

两种方法：

1、广度优先搜索

代码：

class Solution{
    public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        int num=numCourses;
        vector<int> in_degree(numCourses,0); //用来保存所有顶点的入度
        vector<vector<int>> adjGraph(numCourses); // 存储邻接表
        queue<int> q;

        for(int i=0;i<prerequisites.size();i++){
            in_degree[prerequisites[i][0]]++;
            adjGraph[prerequisites[i][1]].push_back(prerequisites[i][0]);
        }

        // 将入度为0 点的点压栈
        for(int i=0;i<numCourses;i++){
            if(in_degree[i]==0){
                q.push(i);
                num--;
            }
        }

        while(!q.empty()){
            int temp=q.front();
            q.pop();
            for(int i=0;i<adjGraph[temp].size();i++){
                if((--in_degree[adjGraph[temp][i]])==0){
                    q.push(adjGraph[temp][i]);
                    num--;
                }
            }
        }
        if(num==0){
            return true;
        }
        return false;
    }
};

2、深度优先搜索

代码：

class Solution{
    public:
        bool canFinish(int numCourses, vector<vector<int>>& prerequisites){
            vector<int> flag(numCourses,0);
            vector<vector<int>> adjacency(numCourses);

            for(int i=0;i<prerequisites.size();i++){
                adjacency[prerequisites[i][1]].push_back(prerequisites[i][0]);
            }

            for(int i=0;i<numCourses;i++){
                if(dfs(i,adjacency,flag)==false){
                    return false;
                }
            }
            return true;

        }
        bool dfs(int i,vector<vector<int>> &adjacency,vector<int> & flag){
            if(flag[i]==-1){
                return true;
            }
            if(flag[i]==1){
                return false;
            }
            flag[i]=1;
            for(int j=0;j<adjacency[i].size();j++){
                if(dfs(adjacency[i][j],adjacency,flag)==false){
                    return false;
                }
            }
            flag[i]=-1;
            return true;
        }
};