【LeetCode: 1462. 课程表 IV:拓扑排序+图+广度优先搜索】

🌲 算法刷题专栏 | 面试必备算法 | 面试高频算法 🍀
🌲 越难的东西,越要努力坚持，因为它具有很高的价值，算法就是这样✨
🌲 作者简介：硕风和炜，CSDN-Java领域优质创作者🏆，保研|国家奖学金|高中学习JAVA|大学完善JAVA开发技术栈|面试刷题|面经八股文|经验分享|好用的网站工具分享💎💎💎
🌲 恭喜你发现一枚宝藏博主,赶快收入囊中吧🌻
🌲 人生如棋，我愿为卒，行动虽慢，可谁曾见我后退一步？🎯🎯

🚩 题目链接

• 1462. 课程表 IV

⛲ 题目描述

你总共需要上 numCourses 门课，课程编号依次为 0 到 numCourses-1 。你会得到一个数组 prerequisite ，其中 prerequisites[i] = [ai, bi] 表示如果你想选 bi 课程，你 必须 先选 ai 课程。

有的课会有直接的先修课程，比如如果想上课程 1 ，你必须先上课程 0 ，那么会以 [0,1] 数对的形式给出先修课程数对。
先决条件也可以是 间接 的。如果课程 a 是课程 b 的先决条件，课程 b 是课程 c 的先决条件，那么课程 a 就是课程 c 的先决条件。

你也得到一个数组 queries ，其中 queries[j] = [uj, vj]。对于第 j 个查询，您应该回答课程 uj 是否是课程 vj 的先决条件。

返回一个布尔数组 answer ，其中 answer[j] 是第 j 个查询的答案。

示例 1：

输入：numCourses = 2, prerequisites = [[1,0]], queries = [[0,1],[1,0]]
输出：[false,true]
解释：课程 0 不是课程 1 的先修课程，但课程 1 是课程 0 的先修课程。

示例 2：

输入：numCourses = 2, prerequisites = [], queries = [[1,0],[0,1]]
输出：[false,false]
解释：没有先修课程对，所以每门课程之间是独立的。

示例 3：

输入：numCourses = 3, prerequisites = [[1,2],[1,0],[2,0]], queries = [[1,0],[1,2]]
输出：[true,true]

提示：

2 <= numCourses <= 100
0 <= prerequisites.length <= (numCourses * (numCourses - 1) / 2)
prerequisites[i].length == 2
0 <= ai, bi <= n - 1
ai != bi
每一对 [ai, bi] 都 不同
先修课程图中没有环。
1 <= queries.length <= 104
0 <= ui, vi <= n - 1
ui != vi

🌟 求解思路&实现代码&运行结果

---

⚡ 图+拓扑排序

🥦 求解思路

1. 首先在求解这道题目之前，可以先来学习一下前面的题目，课程表1博客地址，课程表2博客地址，这道题目的总体的求解思路和之前的题目一样，需要使用拓扑排序。

2. 改题目的不一样的点在于：先决条件也可以是间接的。举个例子来说，如果课程 a 是课程 b 的先决条件，课程 b 是课程 c 的先决条件，那么课程 a 就是课程 c 的先决条件。那我们怎么来实现这块的代码呢？

3. 求解思路如下:
   

4. 有了基本的思路，接下来我们就来通过代码来实现一下。

🥦 实现代码

class Solution {
    public List<Boolean> checkIfPrerequisite(int numCourses, int[][] prerequisites, int[][] queries) {
        List<Boolean> ans=new ArrayList<>();
        if(numCourses==0||prerequisites==null) return ans;
        List<Integer>[] list=new ArrayList[numCourses];
        Arrays.setAll(list,e->new ArrayList<>());
        Queue<Integer> queue=new LinkedList<>();
        int[] arr=new int[numCourses];
        boolean[][] flag=new boolean[numCourses][numCourses];
        int n=prerequisites.length;
        for(int i=0;i<n;i++){
            int from=prerequisites[i][0],to=prerequisites[i][1];
            list[from].add(to);
            arr[to]++;
        }
        for(int i=0;i<numCourses;i++){
            if(arr[i]==0){
                queue.add(i);
            }
        }
        while(!queue.isEmpty()){
            int next=queue.poll();
            for(int i:list[next]){
                flag[next][i]=true;
                for(int j=0;j<numCourses;j++){
                    flag[j][i]=flag[j][i]|flag[j][next];
                }
                if(--arr[i]==0){
                    queue.add(i);
                }
            }
        }
        for (int[] query : queries) {
            ans.add(flag[query[0]][query[1]]);
        }
        return ans;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

🥦 运行结果

时间复杂度&空间复杂度

---

💬 共勉