在带权树网络中统计可连接服务器对数目

难度: Medium

给你一棵无根带权树，树中总共有 n 个节点，分别表示 n 个服务器，服务器从 0 到 n - 1 编号。同时给你一个数组 edges ，其中 edges[i] = [a_i, b_i, weight_i] 表示节点 a_i 和 b_i 之间有一条双向边，边的权值为 weight_i 。再给你一个整数 signalSpeed 。

如果两个服务器 a ，b 和 c 满足以下条件，那么我们称服务器 a 和 b 是通过服务器 c 可连接的 ：

a < b ，a != c 且 b != c 。
从 c 到 a 的距离是可以被 signalSpeed 整除的。
从 c 到 b 的距离是可以被 signalSpeed 整除的。
从 c 到 b 的路径与从 c 到 a 的路径没有任何公共边。

请你返回一个长度为 n 的整数数组 count ，其中 count[i] 表示通过服务器 i 可连接 的服务器对的数目。

示例 1：

输入：edges = [[0,1,1],[1,2,5],[2,3,13],[3,4,9],[4,5,2]], signalSpeed = 1
输出：[0,4,6,6,4,0]
解释：由于 signalSpeed 等于 1 ，count[c] 等于所有从 c 开始且没有公共边的路径对数目。
在输入图中，count[c] 等于服务器 c 左边服务器数目乘以右边服务器数目。

示例 2：

输入：edges = [[0,6,3],[6,5,3],[0,3,1],[3,2,7],[3,1,6],[3,4,2]], signalSpeed = 3
输出：[2,0,0,0,0,0,2]
解释：通过服务器 0 ，有 2 个可连接服务器对(4, 5) 和 (4, 6) 。
通过服务器 6 ，有 2 个可连接服务器对 (4, 5) 和 (0, 5) 。
所有服务器对都必须通过服务器 0 或 6 才可连接，所以其他服务器对应的可连接服务器对数目都为 0 。

提示：

2 <= n <= 1000
edges.length == n - 1
edges[i].length == 3
0 <= a_i, b_i < n
edges[i] = [a_i, b_i, weight_i]
1 <= weight_i <= 10⁶
1 <= signalSpeed <= 10⁶
输入保证 edges 构成一棵合法的树。

Submission

运行时间: 111 ms

内存: 20.7 MB

# https://leetcode.cn/u/l00/

class Solution:
    def countPairsOfConnectableServers(self, edges: List[List[int]], sp: int) -> List[int]:
        n = len(edges) + 1
        ans = [0 for _ in range(n)]
        deg = [2] + [0] * (n - 1)
        mix = [0] * n
        ws = {}
        for u, v, w in edges:
            deg[u] += 1
            deg[v] += 1
            mix[u] ^= v
            mix[v] ^= u
            ws[(u,v)] = w % sp
            ws[(v,u)] = w % sp

        queue = []
        for i, d in enumerate(deg):
            if d == 1: queue.append(i)

        wakes = []
        for root in queue:
            while deg[root] == 1:
                next = mix[root]
                mix[next] ^= root
                deg[next] -= 1
                wakes.append((next, root, ws[(next,root)]))
                root = next        

        cntFromSon = [{0:0} for _ in range(n)]
        for u, v, w in wakes:
            lastRes = cntFromSon[u][0]
            cntFromSon[v][0] += 1
            for k, c in cntFromSon[v].items():
                newK = (k + w) % sp
                cntFromSon[u][newK] = cntFromSon[u].get(newK, 0) + c
            newRes = cntFromSon[u][0]
            ans[u] += (newRes - lastRes) * lastRes

        cntFromFar = [{} for _ in range(n)]
        cntFromFar[0][0] = 1
        for u, v, w in wakes[::-1]:
            for k, c in cntFromFar[u].items():
                newK = (k + w) % sp
                cntFromFar[v][newK] = cntFromFar[v].get(newK, 0) + c
            for k, c in cntFromSon[u].items():
                newK = (k + w) % sp
                cntFromFar[v][newK] = cntFromFar[v].get(newK, 0) + c
            for k, c in cntFromSon[v].items():
                newK = (k + w * 2) % sp
                cntFromFar[v][newK] -= c
            ans[v] += cntFromFar[v].get(0, 0) * (cntFromSon[v].get(0, 0) - 1)
        return ans

Explain

题解的思路主要是使用 BFS 来遍历树，并通过动态规划的方法来计算可连接的服务器对数。首先，对于每个节点，我们记录它的度数（连接的边数）和与其相连的节点。然后，从度数为 1 的节点（叶子节点）开始，依次向上遍历，直到到达根节点。在这个过程中，我们记录从每个节点出发，到达其子节点的路径长度对 signalSpeed 的余数，以及通过该节点可以连接的服务器对数。最后，我们再次从根节点向下遍历，更新每个节点的可连接服务器对数，并计算最终结果。

时间复杂度: O(n^2)

空间复杂度: O(n)

class Solution:
    def countPairsOfConnectableServers(self, edges: List[List[int]], sp: int) -> List[int]:
        n = len(edges) + 1
        ans = [0 for _ in range(n)]
        deg = [2] + [0] * (n - 1)  # 记录每个节点的度数
        mix = [0] * n  # 记录每个节点与其相连的节点
        ws = {}  # 记录每条边的权重对 signalSpeed 的余数
        for u, v, w in edges:
            deg[u] += 1
            deg[v] += 1
            mix[u] ^= v
            mix[v] ^= u
            ws[(u,v)] = w % sp
            ws[(v,u)] = w % sp

        queue = []
        for i, d in enumerate(deg):
            if d == 1: queue.append(i)  # 从叶子节点开始遍历

        wakes = []
        for root in queue:
            while deg[root] == 1:
                next = mix[root]
                mix[next] ^= root
                deg[next] -= 1
                wakes.append((next, root, ws[(next,root)]))
                root = next        

        cntFromSon = [{0:0} for _ in range(n)]
        for u, v, w in wakes:
            lastRes = cntFromSon[u][0]
            cntFromSon[v][0] += 1
            for k, c in cntFromSon[v].items():
                newK = (k + w) % sp
                cntFromSon[u][newK] = cntFromSon[u].get(newK, 0) + c
            newRes = cntFromSon[u][0]
            ans[u] += (newRes - lastRes) * lastRes

        cntFromFar = [{} for _ in range(n)]
        cntFromFar[0][0] = 1
        for u, v, w in wakes[::-1]:
            for k, c in cntFromFar[u].items():
                newK = (k + w) % sp
                cntFromFar[v][newK] = cntFromFar[v].get(newK, 0) + c
            for k, c in cntFromSon[u].items():
                newK = (k + w) % sp
                cntFromFar[v][newK] = cntFromFar[v].get(newK, 0) + c
            for k, c in cntFromSon[v].items():
                newK = (k + w * 2) % sp
                cntFromFar[v][newK] -= c
            ans[v] += cntFromFar[v].get(0, 0) * (cntFromSon[v].get(0, 0) - 1)
        return ans

Explore

在算法中，我们首先通过 BFS 从叶子节点开始向根节点遍历，确保每次处理的路径是当前叶子节点通过唯一的路径到根的路径。通过这种方式，对于每个节点 c，当我们计算从 c 到其子节点 a 和 b 的路径时，我们是在前一次遍历结束后，分别从 c 独立地向 a 和 b 遍历。这样确保了从 c 到 a 和从 c 到 b 的路径是独立的，不共享任何边。此外，通过动态更新节点的度数和连接关系，确保每个节点作为根时，其子树内的遍历不会回到已经处理过的路径。

在此题解中选择使用 BFS 而非 DFS 主要是因为 BFS 更适合层级性的从外向内（从叶子节点到根节点）的遍历方式。利用 BFS 可以更自然地按层级处理节点，特别是对于每层的叶子节点进行处理时，更容易管理和维护必要的状态信息，如度数、路径权重等。在效率上，BFS 和 DFS 在树结构中的时间复杂度通常相同，均为 O(n)，但在实际应用中，BFS 在此类问题上可能更直观且易于实现正确的状态转移。

从度数为1的节点（叶子节点）开始遍历是因为这些节点在树的结构中位于边缘位置，它们没有子节点，因此可以作为遍历的起点。从叶子节点开始向根节点遍历可以简化问题的处理：每个叶子节点只有一个父节点，这样可以避免复杂的回溯操作，直接向上聚合信息直至根节点。此外，这种方式也便于我们从底向上计算和累积各种需要的状态，如路径权重的余数和可连接服务器对数，因为每处理完一个节点，其父节点就成了新的叶子节点，逐渐减少问题的规模。