Leetcode 207. Course Schedule

方法1: dfs/backtracking + memo 这题其实是一道circle detection的问题。这个思想和lc官方解答2一样，具体思路可以查看lc官方解答2。复杂度复盘时候自己分析。

class Solution {
    Map<Integer, List<Integer>> map = new HashMap<>();
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        buildMap(prerequisites);
        Set<Integer> visited = new HashSet<>();
        boolean[] checked = new boolean[numCourses];
        for(int start : map.keySet()){
            if(backtracking(start, visited, checked)) return false;
        }
        return true;
    }
    
    public boolean backtracking(int start, Set<Integer> visited, boolean[] checked){
        if(checked[start]) return false;
        if(visited.contains(start)) return true;
        if(!map.containsKey(start)) return false;
        visited.add(start);
        boolean res = false;
        for(int course : map.get(start)){
            if(!visited.contains(course)){
                if(backtracking(course, visited, checked)){
                    res = true;
                    break;
                }
            }else{
                res = true;
                break;
            }  
        }
        visited.remove(start);
        checked[start] = true;
        return res;
    }
    
    public void buildMap(int[][] prerequisites){
        for(int[] relation : prerequisites){
            if(map.containsKey(relation[1])){
                map.get(relation[1]).add(relation[0]);
            }else{
                List<Integer> nextCourses = new ArrayList<>();
                nextCourses.add(relation[0]);
                map.put(relation[1], nextCourses);
            }
        }
    }
}

方法2: lc官方解答3，Topological Sort。我现在没看，但是我感觉是一个可以handle的并且不错的算法，复盘的时候自己看一遍然后自己实现。Topological Sort的代码可以参考这个帖子里的最高赞的评论。

总结：

• 无