leetcode27（课程表：拓扑排序）

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

题解(一）：这道题是一道拓扑排序问题，即对于一个给定包含n个结点的有向图，给结点编号并进行排列，若对于图中任意一条有向边（x，y），在排列中x都在y的前面，则称这种排列为拓扑排序，如果一个图中的某一条有向边形成了一个环，则该图一定没有拓扑排序。因为不可能同时满足x在y前面，y也要在x前面。所以对于这道题，我们要做的就是把课程编号当作有向图结点，将课程的先决条件当作方向，构造有向图，判断所构成的图中是否存在闭环。

判断是否存在闭环的方法就是遍历图中结点，找闭环，我们可以使用DFS算法实现找闭环的流程

DFS算法代码

class Solution {
    //hoop用于判断是否成环
    boolean hoop=false;
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        /*
        * map用于存储图中结点，和该结点的有向连接点 
        * search用于存储该结点的状态：0表示该点目前还没有被搜索，
        * 1表示该点正在被搜索，2表示该点已搜索完成
        */
        ArrayList<ArrayList<Integer>>map=new ArrayList<>();
        for(int i=0;i<numCourses;i++){
            map.add(new ArrayList<>());
        }
        //search初始化，元素初始取值全为0（默认）
        int[] search=new int[numCourses];
        for(int i=0;i< prerequisites.length;i++){
            map.get(prerequisites[i][1]).add(prerequisites[i][0]);
        }

        for(int i = 0; i < numCourses&&hoop==false; i++){
            DFS(i,search,map);
        }
        return !hoop;
    }
    /*
    * 进行DFS算法遍历，采用递归的方法，若递归到的该点的
    * 所有有向终点都已经被搜索或者没有有向线，则该点标记为
    * 已搜索，若在搜索的过程中，搜索到的点是标记被为正在搜索的点，
    * 就说明找到了闭环，原有向图没有拓扑排序
    */
    private void DFS(int start,int []search,ArrayList<ArrayList<Integer>>map){
        search[start]=1;
        for(int k:map.get(start)){
            if(search[k]==0)
                DFS(k,search,map);
            else if(search[k]==1)
                hoop=true;
            if(hoop==true)
                return;
        }
        search[start]=2;
    }
}

题解（二）：对于有向图的每一个结点，分别有入边通向这个结点，和出边从这个结点到达其他结点，一个拓扑排序的开头一定没有入边，因为学的第一门课程之前是不需要学任何课程的，学完这门课程后，将这门课程的出边全部删除，若某条出边所对应课程没有任何入边了，则可以顺利学到这门课程，拓扑排序中则可以加入这个结点，然后再删掉这门课程的所有出边，一直这样操作下去，若能够学完所有课程，则该有向图有拓扑排序，否则则没有拓扑排序

import java.util.*;
class Solution {
        public boolean canFinish(int numCourses, int[][] prerequisites) {
            ArrayList<ArrayList<Integer>>map=new ArrayList<>();
            for(int i=0;i<numCourses;i++)
                map.add(new ArrayList<>());
            int[]inCourses=new int[prerequisites.length];
           
            //存储有向图结点和出边入边以及结点入边的个数
            for(int i=0;i< prerequisites.length;i++){
                map.get(prerequisites[i][1]).add(prerequisites[i][0]);
                inCourses[prerequisites[i][1]]++;
            }
            
            //队列中存储目前可以学习的课程（不需要再提前学其他课的课程）
            Queue<Integer>BFS=new LinkedList<>();
            for(int i=0;i<numCourses;i++){
                if(inCourses[i]==0)
                    BFS.add(i);
            }
            int check=0;
            while(!BFS.isEmpty()){
                int head=BFS.poll();
                check++;
                
                //若某结点的入边个数变为零，则说明可以学这门课程了，将其加入BFS队列
                for(int x:map.get(head)){
                    inCourses[x]--;
                    if(inCourses[x]==0)
                        BFS.add(x);
                }
            }
            return check==numCourses;

        }
    }