leetcode 207. 课程表题解

最新推荐文章于 2024-05-26 15:54:39 发布

飞天小女侠~

最新推荐文章于 2024-05-26 15:54:39 发布

阅读量1.4k

点赞数 1

分类专栏：算法文章标签： leetcode 算法职场和发展

本文链接：https://blog.youkuaiyun.com/xuan971130/article/details/126461084

版权

算法专栏收录该内容

5 篇文章

订阅专栏

本文介绍了一种使用哈希映射数据结构解决课程依赖问题的方法。通过建立两个哈希映射，一个存储课程依赖关系，另一个存储被依赖关系。首先寻找无需依赖的入口课程，然后递归检查其依赖课程是否已完成，逐步完成所有课程。如果所有课程完成，返回true，否则返回false。这是一个有效的课程计划算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

力扣

思路：

一、数据结构：

（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<Integer>()).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<Integer> 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<Integer> 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<Integer, ArrayList<Integer>> map;
    HashMap<Integer, ArrayList<Integer>> 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<Integer> list1 = map.getOrDefault(prerequisites[i][0], new ArrayList<Integer>());
            list1.add(prerequisites[i][1]);
            map.put(prerequisites[i][0], list1);
            ArrayList<Integer> list2 = mapped.getOrDefault(prerequisites[i][1], new ArrayList<Integer>());
            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<Integer>()).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<Integer> list1 = mapped.getOrDefault(index, new ArrayList<>());
        if(list1.size() == 0) {
            return false;
        } 
        for(int i = 0 ; i < list1.size(); i++) {
            ArrayList<Integer> 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;

    }
}