方法一：1、建立图 2、对节点进行依次判别所形成的通路是否为环形结构，如果是则返回
    inpath负责标记在寻找通路时对通路的标记，注意回溯的位置，应该是在for循环之后、visisted负责标记已经遍历过的节点，减少多余的遍历，若没有visited计算复杂度将大大增加

    1. class Solution {
    2. public:
    3.     vector<bool> visited;
    4.     vector<bool> onpath;
    5.     bool iscycle=false;
    6.     bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
    7.         visited.resize(numCourses);
    8.         onpath.resize(numCourses);
    9.         vector<vector<int>> graph=builgraph(numCourses, prerequisites);
    10.         for(int i=0;i<numCourses;i++){
    11.             dfs(graph,i);
    12.         }
    13.         return !iscycle;
    14.     }
    15.     vector<vector<int>> builgraph(int numCourses, vector<vector<int>>& prerequisites){
    16.         vector<vector<int>>graph;
    17.         graph.resize(numCourses);
    18.         for(auto prere:prerequisites){
    19.             int from=prere[1];
    20.             int to=prere[0];
    21.             graph[from].emplace_back(to);
    22.         }
    23.         return graph;
    24.     }
    25.     void dfs(vector<vector<int>>& graph,int num){
    26.         if(onpath[num]){
    27.             iscycle=true;
    28.         }
    29.         if(visited[num]||iscycle){
    30.             return;
    31.         }
    32.         visited[num]=true;
    33.         onpath[num]=true;
    34.         for(auto g:graph[num]){
    35.             dfs(graph,g);
    36.         }
    37.         onpath[num]=false;
    39.     }
    40. };

    方法二：BFS，用inter数组记录每个节点在to中的个数，通过遍历对inter[to]—，若在to中的个数为0则压入队列，用visit记录压入队列的数据的个数，若无循环，则visited与numCourses相同

    class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        queue<int> q;
        vector<int>inter;
        inter.resize(numCourses);
        vector<vector<int>>graph=buildgraph(numCourses,prerequisites,inter);
        for(int i=0;i<numCourses;i++){
            if(inter[i]==0){
                q.emplace(i);
            }
        }
        int visited=0;
        while(!q.empty()){
            int temp=q.front();
            q.pop();
            visited++;
            for(auto g:graph[temp]){
                inter[g]--;
                if(inter[g]==0){
                    q.emplace(g);
                }
            }
        }
        return visited==numCourses;
    }
    vector<vector<int>> buildgraph(int num, vector<vector<int>>& prerequisites,vector<int>& inter){
        vector<vector<int>> graph;
        graph.resize(num);
        for(auto i:prerequisites){
            int from=i[1];
            int to=i[0];
            graph[from].emplace_back(to);
            ++inter[to];
        }
        return graph;
    }
};