拓扑排序典型应用

207. 课程表
     你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

//深度遍历的方法
class Solution {
public:
    int *visit;
    bool valid = true;
    vector<vector<int>>edges;
    void dfs(int i)
    {
        visit[i] = 1;
        for (int& u : edges[i])
        {
            if (visit[u] == 0)
            {
                dfs(u);
            }
            else if (visit[u] == 1)
            {
                valid = false;
                return;
            }
        }
        visit[i] = 2;
    }
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        visit = new int[numCourses];
        edges.resize(numCourses);
        for (int i = 0; i < numCourses; i++)
        {
            visit[i] = 0;
        }
        //遍历数组，相当于info[1]指向info[0]
        for (auto& info : prerequisites)
        {
            edges[info[1]].push_back(info[0]);
        }
        //深度遍历数组edges,将遍历到的顶点的相应值赋为1，表示已经访问，如果回溯到了已经访问的顶点，则表示不合理，返回false
        for (int i = 0; i < numCourses&&valid; i++)
        {
            if (visit[i] == 0)
            {
                dfs(i);
            }
        }
        return valid;
    }
};

深度遍历的方法判断，首先创建edges数组，就是边数组，表示各个边之间的关系，edges[i]这一数组表示与第i个元素有关的边，深度遍历数组edges，就是不断遍历，将已经搜索的作标记，在回溯的时候，如果出现已经搜索的，那么此时就构成了环，如果在回溯的时候，也没有遇到当前已经搜索过的点，则做另外一个标记，表示此点是合理的。
时间复杂度为O（n+m）,空间复杂度为O（n+m）

//广度遍历的方法
class Solution {
public:
    vector<vector<int>>edges;
    int* visit;
    int* ind;//记录入度数
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        visit = new int[numCourses];
        ind = new int[numCourses];
        edges.resize(numCourses);
        //初始化ind和visit数组
        for (int i = 0; i < numCourses; i++)
        {
            visit[i] = 0;
            ind[i] = 0;
        }
        //创建edges数组
        for (auto& info : prerequisites)
        {
            edges[info[1]].push_back(info[0]);
            ind[info[0]]++;
        }
        queue<int> Q;
        int count = 0;
        //寻找入度数为0的数
        for (int i = 0; i < numCourses; i++)
        {
            if (ind[i] == 0)
            {
                Q.push(i);
                visit[i] = 1;
                count++;
            }
        }
        if (Q.empty())
        {
            return false;
        }
        while (!Q.empty())
        {
            int k = Q.front();
            for (int i = 0; i < edges[k].size(); i++)
            {
                ind[edges[k][i]]--;
                if (ind[edges[k][i]] == 0 && visit[edges[k][i]] == 0)
                {
                    Q.push(edges[k][i]);
                    visit[edges[k][i]] = 1;
                    count++;
                }
            }
            Q.pop();
        }
        return count == numCourses;
    }
};

广度遍历的方法，用一个数组记录入度数，将入度数为0的点入队列，直到队列为空，计数队列大小和课程总数的大小
时间复杂度为O（n+m）,空间复杂度为O（n+m）