方法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的代码可以参考这个帖子里的最高赞的评论。
总结:
- 无