leetcode 207. 课程表题解

力扣

 思路：

一、数据结构：

（1）使用哈希map：  map存储每个课程所需要的依赖关系：key为课程，value为ArrayList，存储完成key的课程所需要完成的其他课程。

（2）使用哈希map：mapped，存储被依赖关系。key为课程，value为ArrayList，存储哪些课程需要key课程完成以后，才能完成。

（3）使用一个flag数组，flag[i] = 0,表示课程未完成。flag[i] = 1,表示该课程完成。

二、思路：

（1）首先要找到入口课程，（即当前可以完成的课程）

当该课程不需要依赖其他课程，那么该课程就可以率先完成。

  count = 0;//使用count来记录当前课程完成数量
        for(int i = 0 ; i < numCourses; i++) {
            if(flag[i] == 0 && map.getOrDefault(i,new ArrayList()).size() == 0) {
                flag[i] = 1; //该课程完成
                count++; //课程完成数目加一
                 if(count == flag.length) {  //如果课程完成数量和总课程数量相等，那么全部课程完成
                    return true;
                }
                boolean res = track(i);  
                if(res == true || count == flag.length) {
                    return true;
                }
            } 
        }

（2）该课程i完成后，我们要从mapped中获取，哪些课程是需要依赖课程i的。找到以后，遍历查询   依赖课程i的   课程j的依赖  是否全部完成，如果全部完成，再把课程j设为完成。并更新count和flag。直到count == 课程总数目，返回true。否则返回false。

boolean track(int index) {
        ArrayList list1 = mapped.getOrDefault(index, new ArrayList<>());
        if(list1.size() == 0) {
            return false;
        } 
        //list1中存的是依赖课程index的全部课程
        for(int i = 0 ; i < list1.size(); i++) {
            //list2中存的是课程i的全部依赖课程
            ArrayList list2 = map.getOrDefault(list1.get(i), new ArrayList<>());
            int judge = 0;
            //遍历课程i的依赖是否全部完成。
            for(int j = 0; j < list2.size(); j++) {
                if(flag[list2.get(j)] == 0) {
                    judge = 1;
                    break;
                }
            }
            //若全部完成，则该课程i，也可以完成
            if(judge == 0) {
                flag[list1.get(i)] = 1;
                count++;
                 System.out.println(count);
                if(count == flag.length) {
                    return true;
                }
                boolean res = track(list1.get(i));
                if(res == true || count == flag.length) {
                    return true;
                }
            }
        }
        return false;

    }

总的代码：

class Solution {
    HashMap> map;
    HashMap> mapped;
    int[] flag;
    int count;
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        map = new HashMap<>();
        mapped = new HashMap<>();
        flag = new int[numCourses];
        for(int i = 0; i < prerequisites.length; i++) {
            if(prerequisites[i][0] == prerequisites[i][1]) {
                return false;
            }
            ArrayList list1 = map.getOrDefault(prerequisites[i][0], new ArrayList());
            list1.add(prerequisites[i][1]);
            map.put(prerequisites[i][0], list1);
            ArrayList list2 = mapped.getOrDefault(prerequisites[i][1], new ArrayList());
            list2.add(prerequisites[i][0]);
            mapped.put(prerequisites[i][1], list2);
        }
        count = 0;
        for(int i = 0 ; i < numCourses; i++) {
            if(flag[i] == 0 && map.getOrDefault(i,new ArrayList()).size() == 0) {
                flag[i] = 1;
                count++;
                 if(count == flag.length) {
                    return true;
                }
                boolean res = track(i);
                if(res == true || count == flag.length) {
                    return true;
                }
            } 
        }
        return false;
    }
    boolean track(int index) {
        ArrayList list1 = mapped.getOrDefault(index, new ArrayList<>());
        if(list1.size() == 0) {
            return false;
        } 
        for(int i = 0 ; i < list1.size(); i++) {
            ArrayList list2 = map.getOrDefault(list1.get(i), new ArrayList<>());
            int judge = 0;
            for(int j = 0; j < list2.size(); j++) {
                if(flag[list2.get(j)] == 0) {
                    judge = 1;
                    break;
                }
            }
            if(judge == 0) {
                flag[list1.get(i)] = 1;
                count++;
                 System.out.println(count);
                if(count == flag.length) {
                    return true;
                }
                boolean res = track(list1.get(i));
                if(res == true || count == flag.length) {
                    return true;
                }
            }
        }
        return false;

    }
}