【LetMeFly】1462.课程表 IV：拓扑排序

力扣题目链接：https://leetcode.cn/problems/course-schedule-iv/

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

有的课会有直接的先修课程，比如如果想上课程 1 ，你必须先上课程 0 ，那么会以 [0,1] 数对的形式给出先修课程数对。

先决条件也可以是间接的。如果课程 a 是课程 b 的先决条件，课程 b 是课程 c 的先决条件，那么课程 a 就是课程 c 的先决条件。

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

返回一个布尔数组 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 <= a_i, b_i <= n - 1
a_i != b_i
每一对 [a_i, b_i] 都不同
先修课程图中没有环。
0 <= u_i, v_i <= n - 1
u_i != v_i

方法一：拓扑排序

首先，在确定课程的先后关系上，这道题类似于LeetCode 207.课程表，使用拓扑排序进行解决即可。

那么，问题是对于 $10^4$ 个query，如何快速返回每次的查询呢？

我们可以建立一个 $numCourses\times numCourses$ 的布尔类型的数组 $i s P re$ 。 $i s P re [a] [b]$ 代表课程 $a$ 是否为课程 $b$ 的先修课。（这样，对于某个查询 $q$ ，只需要返回 $i s P re [q [0]] [q [1]]$ 即可）

在拓扑排序时，如果确定了thisCourse是nextCourse的先修课，那么所有thisCourse的先修课都是nextCourse的先修课。用公式表示即为：

$\forall 0\leq i\leq numCourses,\ \ isPre[i][nextCourse]\ \ |=\ isPre[i][thisCourse]$

时间复杂度 $O(numCourses^2 + n + q)$ ，其中 $n$ 是先修课关系数， $q$ 是查询的个数
空间复杂度 $O(numCourses^2 + n)$

AC代码

C++

class Solution {
public:
    vector<bool> checkIfPrerequisite(int numCourses, vector<vector<int>>& prerequisites, vector<vector<int>>& queries) {
        // 建图
        vector<vector<int>> graph(numCourses);
        vector<int> indegree(numCourses);
        for (vector<int>& ab : prerequisites) {
            graph[ab[0]].push_back(ab[1]);
            indegree[ab[1]]++;
        }

        // 初始化队列
        queue<int> q;
        for (int i = 0; i < numCourses; i++) {
            if (!indegree[i]) {
                q.push(i);
            }
        }

        // 预处理（拓扑排序）
        vector<vector<bool>> isPre(numCourses, vector<bool>(numCourses, false));
        while (q.size()) {
            int thisCourse = q.front();
            q.pop();
            for (int nextCourse : graph[thisCourse]) {
                indegree[nextCourse]--;
                if (!indegree[nextCourse]) {
                    q.push(nextCourse);
                }
                isPre[thisCourse][nextCourse] = true;
                for (int i = 0; i < numCourses; i++) {
                    isPre[i][nextCourse] = isPre[i][nextCourse] | isPre[i][thisCourse];  // vector不支持|=
                }
            }
        }

        // 查询
        vector<bool> ans;
        for (vector<int>& q : queries) {
            ans.push_back(isPre[q[0]][q[1]]);
        }
        return ans;
    }
};

Python

# from typing import List

class Solution:
    def checkIfPrerequisite(self, numCourses: int, prerequisites: List[List[int]], queries: List[List[int]]) -> List[bool]:
        graph = [[] for _ in range(numCourses)]
        indegree = [0] * numCourses
        for a, b in prerequisites:
            graph[a].append(b)
            indegree[b] += 1
        
        q = []
        for i in range(numCourses):
            if not indegree[i]:
                q.append(i)
        
        isPre = [[False for _ in range(numCourses)] for __ in range(numCourses)]
        while q:
            thisCourse = q.pop()
            for nextCourse in graph[thisCourse]:
                indegree[nextCourse] -= 1
                if not indegree[nextCourse]:
                    q.append(nextCourse)
                isPre[thisCourse][nextCourse] = True
                for i in range(numCourses):
                    isPre[i][nextCourse] |= isPre[i][thisCourse]
        
        ans = []
        for a, b in queries:
            ans.append(isPre[a][b])
        return ans