[leetcode每日一题2020/8/4]207. 课程表

题目来源于leetcode，解法和思路仅代表个人观点。传送门。
难度：中等
用时：02:00:00（断断续续应该在两个小时左右）

题目

你这个学期必须选修 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. 输入的先决条件是由 边缘列表 表示的图形，而不是邻接矩阵。详情请参见图的表示法。
2. 你可以假定输入的先决条件中没有重复的边。
3. 1 <=numCourses <= 10^5

思路

1. 一看下来，本来还没想到合适的解法。但是瞄了一眼提示之后，发现可以把题目给的prerequisites转换成图的形式。这题原来是有关图的问题。
2. prerequisites给的是二维数组[n][2]。行为n，列固定为2。(这点我翻了一下评论才发现）

• 仔细分析一下，prerequisites可以看成有向图的边，一共有numCourse个顶点。
• 那么，给出什么样的图，不可能完成所有的课程？答案是：如果存在环路。
• 知道了这一点，那么解题思路就有很多，下面我就说一下我的方法（DFS）。
  

DFS
总体思路：遍历每个顶点，看其所有出路中是否都能找到到达终点(该点没有出路（前置课程），且不成环的路径。

1. flagCourses代表当前课程是否可以学习
2. courses保存处理后的prerequisites
3. 依次遍历每一个course，看其是否能够被学习。

• 如果不能被学习，立马返回ans=false。
• 如果所有课程都能够被学习，则返回ans=true。

4. 方法isCanLearn表示深度遍历该课程是否能够被学习。返回false的情况有，如果重复遍历了某个课程（此时flag[当前节点]=true）。
5. 方法isCanLearn还需要一些记忆处理，加快DFS的速度（不然超时）。

• 依次遍历它的前置课程的时候，如果之前的DFS已经标记该课程可以学习，那么直接跳过该课程（继续下一个）。
• 依次遍历它的前置课程的时候，如果前置课程返回false了。说明，已经不可能遍历（学）完所有顶点（课程）了，直接返回false，结束DFS。（如果这里不直接return的话，会超时）。
  注：由于prerequisites给的是没有顺序和结构的数组。所以需要预处理一下（这里处理成了邻接表）。不然由于每次都要一个循环（O(n)）查找某个课程的前置课程，导致超时（处理之后，O(1)）。

代码

class Solution {
    class course{
        //当前课程
        int id;
        //前置课程的id
        List<Integer> preCourses = new ArrayList<Integer>();
        course(int id){
            this.id = id;
        }
    }

    //flagCourses记录当前课程是否可以学习 
    boolean[] flagCourses;
    //numCourse个course保存处理后的prerequisites
    List<course> courses;

    public boolean canFinish(int numCourses, int[][] prerequisites) {
        //flagCourses初始化    
        flagCourses = new boolean[numCourses];
        //预处理，将题目给的条件传换成，容易处理的形式
        //1.生成numCourse个course
        courses = new ArrayList<course>();
        for(int i=0;i<numCourses;i++){
            courses.add(new course(i));
        }
        //2.扫描prerequisites的数据，转换成course的数据
        for(int i=0;i<prerequisites.length;i++){
            courses.get(prerequisites[i][0]).preCourses.add(prerequisites[i][1]);
        }
        //3.遍历每一个course，看看该课程是否能够被学习
        //该课程是否能够学习，取决于它的前置课程
        boolean ans = true;
        for(int i=0;i<numCourses;i++){
            if(flagCourses[i] == true){
                continue;
            }
            boolean[] flag = new boolean[numCourses];
            if(!isCanLearn(i,flag)){
                ans = false;
                break;
            }
        }
        return ans;
    }
    //i表示当前课程id，flag表示当前课程是否遍历过
    private boolean isCanLearn(int p,boolean[] flag){
        //如果该课程已经被标记过了，说明课程之前存在回路了，该课程无法被学习
        if(flag[p] == true){
            flagCourses[p] = false;
            //flag[p] = false;
            return false;
        }
        //标记该课程已经被遍历过了
        flag[p] = true;
        //依次遍历他的前置课程
        for(int i=0;i<courses.get(p).preCourses.size();i++){
            int preId = courses.get(p).preCourses.get(i);
            //如果它的前置课程已经被标记过可以学习，那么
            if(flagCourses[preId]){
                continue;
            }
            //只要它的前置课程有一个是不能学的，那么该课程就不能学。那么就证明，无法修完所有课程
            if(!isCanLearn(preId,flag)){
                return false;
            }
        }
        //当前课程是否能够学习，取决于它的前置课程（是否能够学习）
        flagCourses[p] = true;
        //标记该课程还没有被遍历
        flag[p] = false;
        return flagCourses[p];
    }
}

算法复杂度分析

时间复杂度： O(n+m)。n为课程数（顶点），m为prerequisites的数量（边）。
空间复杂度： O(n+m)。n为记录该课程是否能够被学习，m为邻接表平均空间。