LeetCode 207 课程表 图 拓扑排序

你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。
在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。
例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。 请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

示例 1：

输入：numCourses = 2, prerequisites = [[1,0]] 输出：true 解释：总共有 2 门课程。学习课程 1
之前，你需要完成课程 0 。这是可能的。

示例 2：

输入：numCourses = 2, prerequisites = [[1,0],[0,1]] 输出：false

解释：总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。

解法一：广度排序
思想：设立一个队列来存储入度为0的元素。每当元素出队时，该顶点遍历邻接表（从该顶点出发），删除对应边（即出边所指的顶点入度-1），然后判断该所指顶点入度是否为0，若为0再放入队列，每次出队时代表该顶点已被访问，count+1，这样的做法可以省去visited数组的存储空间。

class Solution {
public:
    int count;
    vector<vector<int>> gra;
    vector<int> indegree;
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        queue<int> q;
        count=0;
        gra.resize(numCourses);
        indegree.resize(numCourses);
        for(const auto&ele:prerequisites)
        {
            gra[ele[0]].push_back(ele[1]);
            indegree[ele[1]]++;
        }
        for(int i=0;i<numCourses;i++)
        {
            if(indegree[i]==0) q.push(i);
        }
        while(!q.empty())
        {
            int p=q.front();//入度为0的元素出列
            q.pop();
            count++;
            //将从该顶点的出发的边删去
            // for(int i=gra[p].size()-1;i>=0;i--)
            for(int to:gra[p])  //遍历写法，跟java有点类似
            {
               indegree[to]--;
               //在这里，将入度为0的点再次入队
               if(!indegree[to]) q.push(to);
            }
        }
        return count==numCourses;

        /*一开始担心有环时会导致顶点被访问1次以上，实际上有环时这些顶点入度永远无法为0，
        是无法加入队列的，这样一来就可以直接用一个count来计数是否所有顶点入度都为0被访问过，而不用visited数组
        */
    }
};

解法二：深度排序.
思想：若不考虑有环的情况，则普通的dfs得到的结果是正确的。若考虑环的情况，需要设置一个flag和visited设置三种状态来判断是否有顶点在一次深度探索过程中未回溯就有顶点指向它。那么就需要有另一种visited状态来标识该点是已经被完全访问完（指该顶点的邻接表也遍历完）即visited=2，而访问后遍历该顶点的邻接表过程中为visited=1。
valid=1时提前结束dfs过程.
code:

class Solution {
public:
    int count;
    vector<vector<int>> gra;
    vector<int> visited;
    int valid;
    /*
    visited三种状态 0代表未访问，1代表访问中，2代表已访问完毕(即已遍历完该顶点的邻边)
    */
    void DFS(int v)
    {
        visited[v]=1;
        for(auto ele:gra[v])
        {
            if(visited[ele]==0&&valid==0) {
                DFS(ele);
                if(valid==1) return ;
            }
            else if(visited[ele]==1) {
                valid=1;//这个顶点已经在搜索中
                return ;
            }
            
        }
        //比dfs多加的一步：
        visited[v]=2;
        
    }
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        queue<int> q;
        valid=0;
        gra.resize(numCourses);
        visited.resize(numCourses,false);
        for(const auto&ele:prerequisites)
        {
            gra[ele[0]].push_back(ele[1]);
        }
        for(int i=0;i<numCourses&&!valid;i++)
        {
            if(visited[i]==0) DFS(i);
        }
              
        return valid==0;

    }
};