图/环 （更新至8.15）

优美地求距离

给你一个 n 个节点的 有向图 ，节点编号为 0 到 n - 1 ，每个节点 至多 有一条出边。

有向图用大小为 n 下标从 0 开始的数组 edges 表示，表示节点 i 有一条有向边指向 edges[i] 。如果节点 i 没有出边，那么 edges[i] == -1 。

同时给你两个节点 node1 和 node2 。

请你返回一个从 node1 和 node2 都能到达节点的编号，使节点 node1 和节点 node2 到这个节点的距离 较大值最小化。如果有多个答案，请返回 最小 的节点编号。如果答案不存在，返回 -1 。

注意 edges 可能包含环。

输入：edges = [2,2,3,-1], node1 = 0, node2 = 1
输出：2
解释：从节点 0 到节点 2 的距离为 1 ，从节点 1 到节点 2 的距离为 1 。
两个距离的较大值为 1 。我们无法得到一个比 1 更小的较大值，所以我们返回节点 2

这道题的解法其实不难，求node1、node2到所有结点的距离，然后遍历距离，找最小的最大值。主要是如何求所有结点距离，题解写的真的蛮优美的，而且避免了出现环在一直打转。

class Solution:
    def closestMeetingNode(self, edges: List[int], node1: int, node2: int) -> int:
        n, min_dis, ans = len(edges), len(edges), -1
        def calc_dis(x: int) -> List[int]:
            dis = [n] * n
            d = 0
            while x >= 0 and dis[x] == n:
                dis[x] = d
                d += 1
                x = edges[x]
            return dis
        for i, d1, d2 in zip(range(n), calc_dis(node1), calc_dis(node2)):
            d = max(d1, d2)
            if d < min_dis:
                min_dis, ans = d, i
        return ans

重点看函数 calc_dis。
如何避免环？——初始距离设置为最大值，如果遍历到的时候距离不是最大值了，就停止。

内向基环

这个题好复杂，看原解答把。

力扣题

解答的知识点有
1.处理这种问题的时候，先对数据做预处理。（在本题中，处理入度，甚至还做了反图）
2.在一个有环的图中，如何减去树枝？——从入度为0的结点出发，进行拓扑排序，遍历到的结点入度- 1。这样入度不为0的点就剩下是环了。（可以脑补一下）
3.如何得到多环图里环的长度？——这个和上一题差不多。遍历环上的点进行计数。
①记录起点，回到起点终止
②该点如果访问过，入度置为-1，下一次访问的时候跳过。

原来这能用到拓扑排序

给你下标从 0 开始、长度为 n 的字符串 pattern ，它包含两种字符，‘I’ 表示 上升 ，‘D’ 表示 下降 。

你需要构造一个下标从 0 开始长度为 n + 1 的字符串，且它要满足以下条件：

num 包含数字 ‘1’ 到 ‘9’ ，其中每个数字 至多 使用一次。
如果 pattern[i] == ‘I’ ，那么 num[i] < num[i + 1] 。
如果 pattern[i] == ‘D’ ，那么 num[i] > num[i + 1] 。
请你返回满足上述条件字典序 最小 的字符串 num。

示例 1：

输入：pattern = “IIIDIDDD”
输出：“123549876”
解释：
下标 0 ，1 ，2 和 4 处，我们需要使 num[i] < num[i+1] 。
下标 3 ，5 ，6 和 7 处，我们需要使 num[i] > num[i+1] 。
一些可能的 num 的值为 “245639871” ，“135749862” 和 “123849765” 。
“123549876” 是满足条件最小的数字。
注意，“123414321” 不是可行解因为数字 ‘1’ 使用次数超过 1 次。

这道题的贪心解法就不说了，毕竟贪心没有太多学习的价值。这道题的字符串可以看成一张图！

借助拓扑排序解决本问题：
①如果arr[x] 和arr[x+1] 的关系为’I’，构建一条有向边将序号为 x + 1的节点接在序号为 x 的节点后；
②如果arr[x] 和 arr[x+1] 的关系为’D’，构建一条有向边将序号为 x 的节点接在序号为 x + 1 的节点后。
这样一来，整个串的数字大小关系就可以借助这幅图表达了，沿着有向边走数字逐渐递增。我们考虑采用堆 + 队列的组合，拓扑排序后每次从队列中弹出的数字都是入度为 0 且未赋值数字中下标最小的，按照顺序赋值从 1 开始赋值就可以得到最小的数字。

class Solution:
    def smallestNumber(self, pattern: str) -> str:
        n = len(pattern)
        ans = ["" for _ in range(n + 1)]
        inDegree = [0 for _ in range(n + 1)]
        g = defaultdict(list)
        for idx, val in enumerate(pattern):
            if val == "I":
                g[idx].append(idx + 1)
                inDegree[idx + 1] += 1
            elif val == "D":
                g[idx + 1].append(idx)
                inDegree[idx] += 1
        queue = []
        for i in range(n + 1):
            if inDegree[i] == 0:
                heapq.heappush(queue, i)
        count = 1
        while queue:
            node = heapq.heappop(queue)
            ans[node] = str(count)
            count += 1
            edges = g[node]
            for edge in edges:
                inDegree[edge] -= 1
                if inDegree[edge] == 0:
                    heapq.heappush(queue, edge)
        return "".join(ans)

这里再说几个点：
①拓扑排序如何选择结点进队？——遍历刚才出队结点的边的入度，（因为都要 -1），如果入度减到0了，该节点入队。而不是遍历所有结点！