leetcode 207 课程表

透过现象看本质，其实就是找这些课程构成的图中是否存在环。自己写了一个朴素的拓扑排序，其中通过入度和出度判断。不断的循环，找到入度为0的节点，并且删除所有以该点为起点的边，之后再进行循环。若是找不到入度为0的起点并且节点数不为0，则代表存在环，反之则不存在。贴民工代码

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) 
    {
        vector<vector<int>> pre(numCourses);
        //入度
        vector<int> in(numCourses,0);
        //出度
        vector<int> out(numCourses,0);
        for(vector<int>& temp:prerequisites)
        {
            pre[temp[1]].push_back(temp[0]);
            in[temp[0]]++;
            out[temp[1]]++;
        }
        int newSize = numCourses;
        queue<int> que; 
        while(1)
        {
            //找到入度为0的节点
            for(int i = 0 ; i< numCourses ; i++)
            {
                if(in[i] == 0)
                que.push(i);
            }
            //cout<<in[0]<<endl;
            if(que.empty() && newSize>0)
            return false;
            else if(que.empty() && newSize == 0)
            return true;
            //将对应的边删除
            while(!que.empty())
            {
                int tempOut = que.front();
                //cout<<tempOut<<endl;
                for(auto temp:pre[tempOut])
                {
                    //cout<<temp<<endl;
                    //cout<<in[temp]<<endl;
                    //对应的节点的入度-1
                    in[temp]--;
                }
                que.pop();
                newSize--;
                //入度变为-1，代表删除
                in[tempOut]--;
            }
        }
        return false;  
    }
};

看了一下题解，上面这种算是广度优先搜索，而深度优先搜索的方法就需要用到递归。对于某一个节点有三种状态，未搜索，已搜索与搜索中。对于某一个未搜索节点，去搜索其所有的周围节点，周围节点探索完成之后就回溯到本结点，并将其入栈，视作已搜索。如果搜索过程中遇到一个搜索中的节点，说明从该节点出发能够回到该节点，说明拓扑中存在环。

class Solution {
public:
    vector<vector<int>> edges;
    vector<int> visited;
    bool vaild = true;
    void dfs(int u)
    {
        visited[u] = 1;
        for(int v:edges[u])
        {
            if(visited[v] == 0)
            {
                dfs(v);
                if(!vaild)
                return;
            }
            else if(visited[v] == 1)
            {
                vaild = false;
                return;
            }
        }
        visited[u] = 2;
    }
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) 
    {
        edges.resize(numCourses);
        visited.resize(numCourses);
        for(const auto& info:prerequisites)
        edges[info[1]].push_back(info[0]); 
        for(int i = 0 ; i < numCourses ; i++)
        {
            if(visited[i] == 0)
            dfs(i);
        }
        return vaild;
    }
};