看完题我就想，这不就是进程里面的死锁问题嘛，进程1等进程2释放锁，进程2等进程3释放锁，进程3等进程1释放锁，这就造成了死锁。或者是spring中的循环依赖问题，BeanA的初始化需要初始化一个BeanB，BeanB的初始化需要初始化BeanA就出现了循环依赖。
我记得的死锁的判断是用简化图的方式，先找出能最先完成的进程，然后把这个点消掉，再找在等待这个进程的进程里面最容易完成看看能不能消掉，消到最后不能消，如果有环就会死锁
而spring中解决循环依赖问题用的是三级缓存就与这道题无关了
如果用简化图就太麻烦了，我就想用hashmap，我把prerequisites数组里的数据以k-v的形式存在HashMap里面，然后用get方法去拿到请求链中的节点放到一个set里面，如果这个节点早就在set中那么就出现了循环，于是几分钟就写出了下面的代码：
class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
int n = prerequisites.length;
Map<Integer, Integer> map = new HashMap<>();
for(int i=0;i<n;i++){
map.put(prerequisites[i][0],prerequisites[i][1]);
}
for(int i =0;i<n;i++){
Integer key = prerequisites[i][0];
Set<Integer> set = new HashSet<>();
set.add(key);
while(map.containsKey(key)){
if(set.contains(map.get(key))){
return false;
}else{
key = map.get(key);
set.add(key);
}
}
}
return true;
}
}然后出错了，
因为我忽略了一门课的选修课有多门，hashmap如果key相同后面的value会覆盖前面的value。然后自己想了很久写没想出来然后就看题解了。
class Solution {
List<List<Integer>> edges;
int visit[];
boolean valid = true;
public boolean canFinish(int numCourses, int[][] prerequisites) {
edges = new ArrayList<List<Integer>>();
for(int i=0;i<numCourses;i++){
edges.add(new ArrayList<Integer>());
}
visit = new int[numCourses];
for(int[] info : prerequisites){
edges.get(info[0]).add(info[1]);
}
for(int i=0;i<numCourses && valid;i++){
if(visit[i] == 0){
dfs(i);
}
}
return valid;
}
public void dfs(int u){
visit[u] = 1;
for(int v : edges.get(u)){
if(visit[v] == 0){
dfs(v);
if(valid == false){
return;
}
}else if(visit[v] == 1){
valid = false;
return;
}
}
visit[u] = 2;
}
}题解用的是深度优先搜索。如果我们把课程作为他的先修课的先行节点，我们可以得到一个图
比如这个图就是要学A就必须先学F，E，C，要学F必须先学E,G，而E和G不需要先学其他课程，所以可以先把E和G学了然后F也可以学了....
题解用的是深度优先遍历可以结合下面的图更方便理解
它用List<List<Integer>> edges的结构构成一个图，外层的List放的是从0到numCourse-1门课程，内层放的是这门课程的先修课程。然后用一个int [] visited数组表是节点的状态，visit[i]=0表示还没有搜索i节点（上图中没有颜色的节点），visit[i]=1表示正在搜索这个节点（上图中黄色的节点），已经搜索过的节点（上图中绿色的节点），然后boolean valid是最后返回的结果，初始化为true，它只能被改成false不能被改成true，所以当有节点出现了死循环就把valid改成false，最后返回的valid就是false不可能是true。
然后先看dfs()方法:
public void dfs(int u){
visit[u] = 1;
for(int v : edges.get(u)){
if(visit[v] == 0){
dfs(v);
if(valid == false){
return;
}
}else if(visit[v] == 1){
valid = false;
return;
}
}
visit[u] = 2;
}课程u进入dfs后先把visit[u]从0改成1，表示正在访问u节点，然后通过edges.get(u)，拿到u课程的所有先修课程vv，然后对这些先修课程v进行判断，
如果先修课程v的visit[v]=0,表示还没有搜索这个课程，递归调用dfs对它进行搜索；
如果visit[v]=1说明这个课程节点在之前已经开始搜索了但是还没有完成搜索，而又重新回到了这个节点，说明出现了环，那么就把valid改成false直接返回；
所以在前面visit[v]=0的情况下，dfs完了，如果valid变成了false就可以直接返回。
所以当visit[v]=2的时候，表示可以搜索到，不用做任何操作，直接进入判断下一个先行课；
当u的所有先修课程都判断完了并且没有出现valid改成fasle返回的情况，那么表明u的所有先修课都可以搜索到，那么u也可以搜索到了，把visit[u]改成2。
然后再看主方法：
public boolean canFinish(int numCourses, int[][] prerequisites) {
edges = new ArrayList<List<Integer>>();
for(int i=0;i<numCourses;i++){
edges.add(new ArrayList<Integer>());
}
visit = new int[numCourses];
for(int[] info : prerequisites){
edges.get(info[0]).add(info[1]);
}
for(int i=0;i<numCourses && valid;i++){
if(visit[i] == 0){
dfs(i);
}
}
return valid;
}先对edges创建一个外层的List，然后再用for循环在这个外层List的每个节点上创建一个Lsit，创建一个visit数组，这都是初始化操作。然后再看下面这个for，他是edges.get(info[0])拿到了外层节点，然后再add(info[1])把先修课挂在了这个节点上，
题解用的是edges.get(info[1]).add(info[0])，我改成了edges.get(info[0]).add(info[1])，因为我觉得这样更好理解，两种都可以跑通。题解是按照上面的图来的，以课程作为他的先修课的先行节点，题解它其实是一个反向图，我们的目的是要判断有没有循环依赖，也就是有没有环，而有没有环与方向的正反无关。
然后只要把所有课程都dfs一遍就可以，for循环里面可以加上&&valid条件，这样一旦fasle后面就不用判断了，效率可以提高一点。
