LeetCode每日打卡 210. 课程表 II

210. 课程表 II

今天这道打卡涉及到有向图的问题，题的难点有两个，一个是如何构建一个图，第二个是必须要把前置课程上完才能够学习后续课程。

首先解决问题一如何构建一个图：
题目中的输入流:
[[1,0],[2,0],[3,1],[3,2]],我们根据前置课程构建图

可以使用HashMap保存图的映射关系

	Map<Integer,List<Integer>> alls = new HashMap<>();
	for (int[] item:prerequisites){
            if(alls.containsKey(item[1])){
                alls.get(item[1]).add(item[0]);
            }else {
                alls.put(item[1],new ArrayList<>(){{add(item[0]);}});
            }
        }

也可以通过自定义Node对象保存图的信息

	public static class Node{
        int curseId;
        //next是平级的 例如上面的0,1,2最后就是0-->1-->2但是对于节点0来说1，2是平级的下级节点
        Node next;
        Node(int curseId){
            this.curseId = curseId;
        }
    }
	
	Node[] graphy = new Node[numCourses];
    for (int i = 0 ;i<numCourses;i++){
       graphy[i] = new Node(i);
    }
    for(int[] item : prerequisites){
            Node start = graphy[item[1]];
            //头插法保存后置节点
            Node temp = start.next;
            start.next = new Node(item[0]);
            start.next.next = temp;
            //度+1
            degree[item[0]]++;
    }

解决第二个问题:必须要把前置课程上完才能够学习后续课程即当前节点的入度为0才能够进行学习

然后根据图可以看出要学习3的条件是必须先把1，2两门课先学习完，因此我们可以根据前置节点统计当前节点的入度

		//统计入度
        int[] degree = new int[numCourses];
        for (int[] item:prerequisites){
            degree[item[0]]++;
        }

然后将入度为0的节点入队，当出队的时候将当前节点的后置节点的入度减一即可
当存在循环节点的时候如:

将永远死循环下去因此需要引入一个used数组表示节点是否遍历

	Deque<Integer> deque = new ArrayDeque<>();
        for (int i= 0 ;i<numCourses;i++){
            if(degree[i] == 0){
                //将度为0的入队
                deque.add(i);
            }
        }
      while (!deque.isEmpty()){
            int k = deque.removeFirst();
            used[k] = true;
            //入结果集
            res[count++] = k;
            List<Integer> list = alls.get(k);
            if (list!=null){
                for (int i = 0;i<list.size();i++){
                    if(!used[list.get(i)]){
                        degree[list.get(i)]--;
                        if(degree[list.get(i)] == 0){
                            deque.add(list.get(i));
                        }
                    }
                }
            }
        }

最后当count == numCourses 即得到我们想要的结果
最后代码如下:

	public int[] findOrderDFS(int numCourses, int[][] prerequisites) {
        if(numCourses<1){
            return new int[]{};
        }
        //统计入度
        int[] degree = new int[numCourses];
        //标记是否使用
        boolean[] used = new boolean[numCourses];
        int[] res = new int[numCourses];
        Map<Integer,List<Integer>> alls = new HashMap<>();
        //统计度
        for (int[] item:prerequisites){
            degree[item[0]]++;
            if(alls.containsKey(item[1])){
                alls.get(item[1]).add(item[0]);
            }else {
                alls.put(item[1],new ArrayList<>(){{add(item[0]);}});
            }
        }
        Deque<Integer> deque = new ArrayDeque<>();
        for (int i= 0 ;i<numCourses;i++){
            if(degree[i] == 0){
                //将度为0的入队
                deque.add(i);
            }
        }
        int count = 0;
        while (!deque.isEmpty()){
            int k = deque.removeFirst();
            used[k] = true;
            //入结果集
            res[count++] = k;
            List<Integer> list = alls.get(k);
            if (list!=null){
                for (int i = 0;i<list.size();i++){
                    if(!used[list.get(i)]){
                        degree[list.get(i)]--;
                        if(degree[list.get(i)] == 0){
                            deque.add(list.get(i));
                        }
                    }
                }
            }
        }
        if(count == numCourses){
            return res;
        }else {
            return new int[]{};
        }
    }

同时我们也可以不通过hashMap去建立映射关系，可以通过遍历prerequisites数组进行入度减少的操作，但是时间比map的要长

	public int[] findOrder(int numCourses, int[][] prerequisites) {
        if(numCourses<1){
            return new int[]{};
        }
        //统计入度
        int[] degree = new int[numCourses];
        //标记是否使用
        boolean[] used = new boolean[numCourses];
        int[] res = new int[numCourses];
        //统计度
        for (int[] item:prerequisites){
            degree[item[0]]++;
        }
        Deque<Integer> deque = new ArrayDeque<>();
        for (int i= 0 ;i<numCourses;i++){
            if(degree[i] == 0){
                //将度为0的入队
                deque.add(i);
            }
        }
        int count = 0;
        while (!deque.isEmpty()){
            int k = deque.removeFirst();
            used[k] = true;
            //入结果集
            res[count++] = k;
            for (int[] item : prerequisites){
                if(item[1] == k && !used[item[0]]){
                    degree[item[0]]--;
                    if(degree[item[0]] == 0){
                        deque.add(item[0]);
                    }
                }
            }
        }
        if(count == numCourses){
            return res;
        }else {
            return new int[]{};
        }
    }

Node方法的代码:

	public int[] findOrder(int numCourses, int[][] prerequisites) {
        if(numCourses<1){
            return new int[]{};
        }
        int[] res = new int[numCourses];
        //----------构建图节点---------------
        Node[] graphy = new Node[numCourses];
        for (int i = 0 ;i<numCourses;i++){
            graphy[i] = new Node(i);
        }
        //统计入度
        int[] degree = new int[numCourses];
        //标记是否使用
        boolean[] used = new boolean[numCourses];
        for(int[] item : prerequisites){
            Node start = graphy[item[1]];
            Node temp = start.next;
            start.next = new Node(item[0]);
            start.next.next = temp;
            //度+1
            degree[item[0]]++;
        }
        Deque<Integer> deque = new ArrayDeque<>();
        //将如度为0的入队列
        for (int i = 0; i <degree.length ; i++) {
            if(degree[i] == 0){
                deque.add(i);
                used[i] = true;
            }
        }
        int count = 0;
        while (!deque.isEmpty()){
            int k = deque.removeFirst();
            //记录课程
            res[count++] = k;
            used[k] = true;
            Node node = graphy[k].next;
            while (node != null){
                if(!used[node.curseId]){
                    //入度减一
                    degree[node.curseId]--;
                    if(degree[node.curseId] == 0){
                        deque.add(node.curseId);
                        used[node.curseId] = true;
                    }
                }
                node = node.next;
            }
        }
        if(count == numCourses){
            return res;
        }else {
            return new int[]{};
        }

    }

上面三种解法本质上都是一致的使用bfs遍历通过入度求解

ps:最近开始带项目了，人很迷茫，也变懒惰了希望还能坚持住把