leetcode 207 课程表

你这个学期必须选修 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。这是不可能的。

方法一：拓扑排序（有向无环图）
1、在开始排序前，扫描对应的存储空间，将入度为 0 的顶点均入队列。
2、只要队列非空，就从队首取出入度为 0 的顶点，将这个顶点输出到结果集中，并且将这个顶点的所有邻接点的入度减 1，在减 1 以后，发现这个邻接点的入度为 0 ，就继续入队。
最后检查结果集中的顶点个数是否和课程数相同即可。

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        //拓扑排序
        int[][] array=new int[numCourses][numCourses];//邻接矩阵
        int[] have=new int[numCourses];//每个节点的入读数量
        int nums=0;//保存个数为入度为0的节点
        Stack<Integer> stack=new Stack<>();
        for(int i=0;i<prerequisites.length;i++){
            array[prerequisites[i][1]][prerequisites[i][0]]=1;
            have[prerequisites[i][0]]++;
        }
        for(int i=0;i<numCourses;i++){
            if(have[i]==0){
                stack.push(i);
            }
        }
        while(!stack.empty()){
            int k=stack.pop();
            nums++;
            for(int i=0;i<numCourses;i++){
                if(array[k][i]==1){
                    have[i]--;
                    if(have[i]==0) stack.push(i);
                }
            }
        }
        return nums==numCourses?true:false;
    }
}

1.借助一个标志列表 flags，用于判断每个节点 i （课程）的状态：
未被 DFS 访问：i == 0；
已被其他节点启动的 DFS 访问：i == -1；
已被当前节点启动的 DFS 访问：i == 1。
2.对 numCourses 个节点依次执行 DFS，判断每个节点起步 DFS 是否存在环，若存在环直接返回 FalseFalse。DFS 流程；
终止条件：
当 flag[i] == -1，说明当前访问节点已被其他节点启动的 DFS 访问，无需再重复搜索，直接返回 TrueTrue。
当 flag[i] == 1，说明在本轮 DFS 搜索中节点 i 被第 22 次访问，即 课程安排图有环 ，直接返回 FalseFalse。
将当前访问节点 i 对应 flag[i] 置 11，即标记其被本轮 DFS 访问过；
递归访问当前节点 i 的所有邻接节点 j，当发现环直接返回 FalseFalse；
当前节点所有邻接节点已被遍历，并没有发现环，则将当前节点 flag 置为 -1−1 并返回 TrueTrue。
3.若整个图 DFS 结束并未发现环，返回 TrueTrue。
复杂度分析：

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        //拓扑排序
        int[][] array=new int[numCourses][numCourses];//邻接矩阵
        int[] flags=new int[numCourses];
        for(int i=0;i<prerequisites.length;i++){//构造邻接矩阵
            array[prerequisites[i][0]][prerequisites[i][1]]=1;
        }
        for(int i=0;i<numCourses;i++){
            if(dfs(flags,array,i)==false) return false;
        }
        return true;
    }
    public boolean dfs(int[] flags,int[][] array,int k){
        if(flags[k]==1) return false;
        if(flags[k]==-1) return true;
        flags[k]=1;
        for(int i=0;i<flags.length;i++){
            if(array[k][i]==1){
                if(dfs(flags,array,i)==false) return false;
            }
        }
        flags[k]=-1;
        return true;
    }
}