2192 有向无环图中一个节点的所有祖先（拓扑排序）

1. 问题描述：

给你一个正整数 n ，它表示一个有向无环图中节点的数目，节点编号为 0 到 n - 1 （包括两者）。给你一个二维整数数组 edges ，其中 edges[i] = [fromi，toi] 表示图中一条从 fromi 到 toi 的单向边。请你返回一个数组 answer，其中 answer[i]是第 i 个节点的所有祖先 ，这些祖先节点升序排序。如果 u 通过一系列边，能够到达 v ，那么我们称节点 u 是节点 v 的祖先节点。

示例 1：

输入：n = 8，edgeList = [[0，3]，[0，4]，[1，3]，[2，4]，[2，7]，[3，5]，[3，6]，[3，7]，[4，6]]
输出：[[]，[]，[]，[0，1]，[0，2]，[0，1，3]，[0，1，2，3，4]，[0，1，2，3]]
解释：
上图为输入所对应的图。
- 节点 0 ，1 和 2 没有任何祖先。
- 节点 3 有 2 个祖先 0 和 1 。
- 节点 4 有 2 个祖先 0 和 2 。
- 节点 5 有 3 个祖先 0 ，1 和 3 。
- 节点 6 有 5 个祖先 0 ，1 ，2 ，3 和 4 。
- 节点 7 有 4 个祖先 0 ，1 ，2 和 3 。

示例 2：

输入：n = 5, edgeList = [[0，1]，[0，2]，[0，3]，[0，4]，[1，2]，[1，3]，[1，4]，[2，3]，[2，4]，[3，4]]
输出：[[]，[0]，[0，1]，[0，1，2]，[0，1，2，3]]
解释：
上图为输入所对应的图。
- 节点 0 没有任何祖先。
- 节点 1 有 1 个祖先 0 。
- 节点 2 有 2 个祖先 0 和 1 。
- 节点 3 有 3 个祖先 0 ，1 和 2 。
- 节点 4 有 4 个祖先 0 ，1 ，2 和 3 。 

提示：

1 <= n <= 1000
0 <= edges.length <= min(2000, n * (n - 1) / 2)
edges[i].length == 2
0 <= fromi，toi <= n - 1
fromi != toi
图中不会有重边。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/all-ancestors-of-a-node-in-a-directed-acyclic-graph/

2. 思路分析：

分析题目可以知道当前节点的祖先节点为从根节点到达当前节点路径上的所有节点，所以最容易想到的是直接dfs遍历所有的节点，使用一个额外的数据结构g1来去重和排序，但是提交上去超时了，后面发现题目中说了是有向无环图所以我们可以使用拓扑排序求解出拓扑序列，当前枚举到拓扑序列中的元素i，那么节点i的所有祖先节点肯定求解出来了，我们将i的所有祖先节点加入进来即可。

3. 代码如下：

import collections
from typing import List


class Solution:
    # 拓扑排序(实际上可以在弹出节点的时候遍历当前节点的出边的时候更新g1)
    def topsort(self, n: int, d: List[int], q: List[int], g: List[List[int]]):
        queue = collections.deque()
        for i in range(n):
            if d[i] == 0:
                queue.append(i)
        while queue:
            p = queue.popleft()
            q.append(p)
            for next in g[p]:
                d[next] -= 1
                if d[next] == 0:
                    queue.append(next)

    def getAncestors(self, n: int, edges: List[List[int]]) -> List[List[int]]:
        g = [list() for i in range(n + 10)]
        d = [0] * (n + 10)
        # q存储拓扑排序序列
        q = list()
        for x, y in edges:
            g[x].append(y)
            # 入度加1
            d[y] += 1
        # g1用来去重和排序
        g1 = [set() for i in range(n + 10)]
        # 求解拓扑排序序列
        self.topsort(n, d, q, g)
        for i in range(n):
            x = q[i]
            for next in g[x]:
                g1[next].add(x)
                # 将g1[x]列表的元素合并到g1[next]中
                g1[next].update(g1[x])
        res = [list() for i in range(n)]
        for i in range(n):
            if g1[i]:
                res[i] = sorted(g1[i])
        return res