课程表(LeetCode两道)题目整理

课程表1

题目描述

你这个学期必须选修 numCourse 门课程，记为 0 到 numCourse-1 。在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们：[0,1]
给定课程总量以及它们的先决条件，请你判断是否可能完成所有课程的学习？来源：力扣（LeetCode207）链接：link

方法1 深度优先搜索

题目本质上就是判断有向图中是否存在环。采用邻接表的形式来进行判断判断，分别从每个节点开始深度优先搜索，判断是否存在环路，如果存在直接返回，用一个数组标记节点是否有环路，可以提前进行剪枝操作，详细看代码注释。

/**
     * 能否完成课程
     *
     * @param numCourses
     * @param prerequisites
     * @return
     */
    public boolean canFinish11(int numCourses, int[][] prerequisites) {
        List<List<Integer>> adj = new ArrayList<>();
        for (int i = 0; i < numCourses; i++) {
            adj.add(new ArrayList<>());
        }
        for (int i = 0; i < prerequisites.length; i++) {
            int end = prerequisites[i][0];
            int start = prerequisites[i][1];
            adj.get(start).add(end);
        }
        int[] flag = new int[numCourses];
        for (int i = 0; i < numCourses; i++) {
            // 如果存在环直接返回
            if (dfs(adj, flag, i)) {
                return false;
            }
        }
        return true;
    }


    /**
     * 深度搜索从当前节点走能否走回来 能就说明有环
     *
     * @param adj
     * @param flag
     * @param i
     * @return
     */
    private boolean dfs(List<List<Integer>> adj, int[] flag, int i) {
        if (flag[i] == 1) return true;   // 如果为1 那个这个节点之前走到过 直接返回false说明存在环
        // 精髓判断剪枝操作
        if (flag[i] == -1) return false;   // 如果为-1 说明当前节点不存在环 提前返回不用继续往后深度优先搜索
        flag[i] = 1;  // 来过之后标记为1
        for (int j : adj.get(i)) {
            if (dfs(adj, flag, j)) {// 继续往后标记
                return true;
            }
        }
        flag[i] = -1; // 标记为-1  //记忆化存储为剪枝操作做铺垫
        return false;
    }

方法2 入度表

进行拓扑排序，看是否所有的节点都能够出AOV网，如果可以那么就不存在环，如果不可以那么就存在环。

/**
     * 入度表
     *
     * @param numCourses
     * @param prerequisites
     * @return
     */
    public boolean canFinish22(int numCourses, int[][] prerequisites) {
        // 初始化入度数组
        int[] indegrees = new int[numCourses];
        // 初始化邻接表
        List<List<Integer>> adjacency = new ArrayList<>();
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < numCourses; i++)
            adjacency.add(new ArrayList<>());
        // 入度数组赋值 邻接表赋值
        for (int[] cp : prerequisites) {
            indegrees[cp[0]]++;
            adjacency.get(cp[1]).add(cp[0]);
        }
        // 找到入度为0 的节点加入到队列当中
        for (int i = 0; i < numCourses; i++)
            if (indegrees[i] == 0) queue.add(i);
        // BFS TopSort.
        // 经典的非空判断
        while (!queue.isEmpty()) {
            int pre = queue.poll();  // 获取节点
            numCourses--;  //课程数减少一个
            // 找到以当前节点直接相连的下一个节点
            for (int cur : adjacency.get(pre))
                // 先把节点入度减一  判断是否等于0  等于0 的话加入到队列
                if (--indegrees[cur] == 0) queue.add(cur);
        }
        // 如果课程没有了说明无环  可以按要求修完
        return numCourses == 0;
    }

课程表2

题目描述

现在你总共有 n 门课需要选，记为 0 到 n-1。在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1] 给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。来源：力扣（LeetCode210）
链接：link
题目的本质就是一个拓扑排序，有可能有多解，因为在选择入度为0的节点进行出序的时候没有限制条件

思路

我们在题目一方法二的基础上记录一下出网的顺序即可，只是需要判断按照题目要求来进行返回，当存在环的时候返回长度为0的数组

/**
     * @param numCourses
     * @param prerequisites
     * @return
     */
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        // 初始化入度数组
        int[] indegrees = new int[numCourses];
        // 初始化邻接表
        List<List<Integer>> adjacency = new ArrayList<>();
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < numCourses; i++)
            adjacency.add(new ArrayList<>());
        // 入度数组赋值 邻接表赋值
        for (int[] cp : prerequisites) {
            indegrees[cp[0]]++;
            adjacency.get(cp[1]).add(cp[0]);
        }
        // 找到入度为0 的节点加入到队列当中
        for (int i = 0; i < numCourses; i++)
            if (indegrees[i] == 0) queue.add(i);
        // BFS TopSort.
        // 经典的非空判断
        int index = 0;// 自增索引
        int[] res = new int[numCourses];
        while (!queue.isEmpty()) {
            int pre = queue.poll();  // 获取节点
            res[index++] = pre;
            numCourses--;  //课程数减少一个
            // 找到以当前节点直接相连的下一个节点
            for (int cur : adjacency.get(pre))
                // 先把节点入度减一  判断是否等于0  等于0 的话加入到队列
                if (--indegrees[cur] == 0) queue.add(cur);
        }
        // 返回的时候需要按照题目要求返回
        if (numCourses == 0) {
            return res;
        } else {
            return new int[0];
        }
    }