门 | GATE CS 2012 | 问题22

题目描述

给定一个有向图和其顶点之间的距离函数，计算从给定节点到其他节点的最短路径的数量。

输入

• V：整数，表示有向图中的节点数。
• E：整数，表示有向图中的边数。
• adj：VxV 的邻接矩阵，表示有向图的邻接矩阵。
• dist：VxV 的矩阵，其中 dist [i] [j] 表示从节点 i 到节点 j 的距离（如果存在一条连接这两个节点的边）。

输出

返回一个列表，其中第 i 个元素表示从给定节点到节点 i 的最短路径数量。

示例

输入:

V = 3, E = 3

adj = [
  [0, 1, 1],
  [0, 0, 1],
  [0, 0, 0]
]

dist = [
  [0, 1, 1],
  [0, 0, 2],
  [0, 0, 0]
]

src = 0

输出:

[1, 1, 2]

解题思路

这道题目要求我们计算给定节点到其他节点的最短路径的数量。为了计算这个数量，我们可以使用动态规划的思想，先计算到每个节点的最短路径，然后用这些信息计算到其他节点的最短路径。

具体地，将最短路径数量的计算分解为两部分：

1. 计算到每个节点的最短路径；
2. 利用这些信息计算到其他节点的最短路径。

对于第一部分的计算，我们使用 Dijkstra 算法。具体地，我们首先初始化一个距离数组，将源节点的距离设为 0，其他节点的距离设为无穷大。然后，我们遍历所有节点，计算到每个节点的最短路径。具体地，我们每次从距离数组中选择距离源节点最近的那个节点 v，并将其标记为已访问。然后，我们遍历 v 的所有邻居节点 w，如果通过 v 可以更新 w 的距离，则更新距离数组，并将 w 添加到一个优先队列中。我们重复这个过程，直到所有节点都被标记为已访问。

对于第二部分的计算，我们使用动态规划。具体地，我们定义一个二维数组 dp，其中 dp [i] [j] 表示从源节点到节点 i 的最短路径数量，其中所有中间节点都不超过 j。初始时，我们将 dp [src] [0] 设置为 1，其他元素设置为 0。然后，我们按照节点的拓扑顺序（即，所有入度为 0 的节点优先）遍历，对于当前的节点 v，我们枚举它的所有入边 (u, v)，并将 dp [v] [j] 累加上 dp [u] [j - dist [u] [v]]，其中 dist [u] [v] 是从节点 u 到节点 v 的距离。

最终，我们返回 dp [i] [j]（其中 j 大于等于到节点 i 的最短路径长度），即从源节点到节点 i 的最短路径数量。

复杂度分析

本题使用了 Dijkstra 算法和动态规划两种算法，下面分别分析它们的时间复杂度。

• Dijkstra 算法的时间复杂度为 $O(V^2)$，其中 $V$ 是节点数。具体地，我们需要遍历所有节点，每次需要在距离数组中选出一个距离源节点最近的节点。
• 动态规划的时间复杂度为 $O(V^3)$。具体地，我们需要计算到每个节点的最短路径，时间复杂度为 $O(V^2)$；然后，对于每个节点，我们需要枚举其所有入边，并计算累加，时间复杂度为 $O(V^3)$。

综上所述，本题的时间复杂度为 $O(V^3)$。

参考代码

下面给出 Python 3 代码实现。

from queue import PriorityQueue

def dijkstra(adj, dist, src):
    n = len(adj)
    ds = [float('inf')] * n
    ds[src] = 0
    
    pq = PriorityQueue()
    pq.put((0, src))
    
    while not pq.empty():
        d, u = pq.get()
        if ds[u] != d:
            continue
        for v in range(n):
            w = dist[u][v]
            if w >= 0:
                if ds[u] + w < ds[v]:
                    ds[v] = ds[u] + w
                    pq.put((ds[v], v))
    
    return ds

def count_shortest_paths(V, E, adj, dist, src):
    # Step 1: compute shortest paths using Dijkstra's algorithm
    ds = dijkstra(adj, dist, src)
    
    # Step 2: compute shortest path counts using dynamic programming
    dp = [[0] * V for _ in range(V)]
    dp[src][0] = 1
    
    for i in range(V):
        for j in range(ds[i], V):
            for u in range(V):
                for v in range(V):
                    if adj[u][v] and ds[u] + dist[u][v] + ds[v] == ds[i] + j:
                        dp[i][j] += dp[u][j - dist[u][v]]
    
    return [dp[i][ds[i]] for i in range(V)]