Python：如何计算通过一个节点的最短路径数？

Question

假设我有一个由NxN 节点组成的常规网络。两个节点之间的最短路径是从源节点到达一个目标节点所需的最小跳数。现在，每条最短路径都会沿途经过许多节点。

我的目标：对于网络中的每个节点，我想计算通过特定节点的最短路径的数量，并将该数字保存在 dict 中。

在这个小例子中，节点 B 有 4 条最短路径通过它： A -> B、A -> C、C -> B、C -> A。 我希望能够为通用图中的每个节点计算这个数字。

我知道我可以使用nx.betweenness_centrality()，但这会给我一个分子（即，对于每个节点，我想要的）除以一个分母，该分母存储两个节点之间所有可能的最短路径。我什至访问了源代码，但我无法弄清楚除法是在哪里进行的。

我知道这是一个冗长的问题，但我没有其他方法来解释我的问题。感谢任何愿意提供帮助的人。

编辑

这是nx.betweenness_centrality() 的源代码。我的图表是无向的。目前尚不清楚哪条线路承载我上面介绍的部门：

def betweenness_centrality(G, k=None, normalized=True, weight=None,
                           endpoints=False,
                           seed=None): #G is the graph

    betweenness = dict.fromkeys(G, 0.0)  
    if k is None:
        nodes = G
    else:
        random.seed(seed)
        nodes = random.sample(G.nodes(), k)
    for s in nodes:
        # single source shortest paths
        if weight is None:  # use BFS
            S, P, sigma = _single_source_shortest_path_basic(G, s)
        else:  # use Dijkstra's algorithm
            S, P, sigma = _single_source_dijkstra_path_basic(G, s, weight)
        # accumulation
        if endpoints:
            betweenness = _accumulate_endpoints(betweenness, S, P, sigma, s)
        else:
            betweenness = _accumulate_basic(betweenness, S, P, sigma, s)
    # rescaling
    betweenness = _rescale(betweenness, len(G),
                           normalized=normalized,
                           directed=G.is_directed(),
                           k=k)
    return betweenness #Returns a dict with the node ID as a key and the value

Answer 1

你可以使用nx.all_pairs_shortest_path(G):

>>> G = nx.Graph()
>>> G.add_path([0,1,2])

>>> spaths = nx.all_pairs_shortest_path(G)
>>> spaths
{0: {0: [0], 1: [0, 1], 2: [0, 1, 2]},
 1: {0: [1, 0], 1: [1], 2: [1, 2]},
 2: {0: [2, 1, 0], 1: [2, 1], 2: [2]}}

它会为您找到图中所有节点对之间的所有最短路径（这对于大型图来说非常昂贵）。然后，下面的代码会给你想要的结果：

def num_spaths(G):
    n_spaths = dict.fromkeys(G, 0.0)
    spaths = nx.all_pairs_shortest_path(G)

    for source in G:
        for path in spaths[source].values():
            for node in path[1:]: # ignore firs element (source == node)
                n_spaths[node] += 1 # this path passes through `node`

    return n_spaths

在你的例子中：

>>> num_spaths(G)
{0: 2.0, 1: 4.0, 2: 2.0}

---

此外，如果您可以进入 all_pairs_shortest_path 代码并仔细编辑它以添加最短路径计数器和

for node in path[1:]:
    n_spaths[node] += 1

这样，您可以在找到路径的同时在线更新路径的数量，而不是在计算完所有路径之后（就像我的代码那样）遍历所有路径。

编辑：in networkx (github)，第 251 行说：

paths[w]=paths[v]+[w]

您可以通过将n_spath 作为参数传递给修改后的函数并在内部更新它来修改该函数以在线更新最短路径的数量（同时找到它们）。然后调用该函数将是：

def num_spaths(G):
    n_spaths = dict.fromkeys(G, 0.0)
    for n in G:
        my_single_source_shortest_path(G, n, n_spaths)
    return n_spaths

和n_spaths 将更新最短路径的数量。

---

编辑：上述方法仅适用于 A 和 B 之间只有 1 条最短路径的情况，因为 nx.all_pairs_shortest_path 每个节点对仅返回一条最短路径。在蛮力搜索下面找到所有可能的最短路径。我不建议在大图中运行它：

def bf_num_spaths(G):
    n_spaths = dict.fromkeys(G, 0.0)

    for source in G:
        for target in G:
            if source == target:
                continue
            for path in nx.all_shortest_paths(G, source, target):
                for node in path[1:]: # ignore firs element (source == node)
                    n_spaths[node] += 1 # this path passes through `node`

    return n_spaths

Answer 2

我相信您可以修改Floyd-Warshall Algorithm 以将路径的长度保存在另一个矩阵中。伪代码（基于维基百科）：

let dist and num be two |V| × |V| arrays of minimum
distances and lengths initialized to ∞ (infinity)

for each vertex v
   dist[v][v] ← 0
   num[v][v] ← 0

for each edge (u,v)
   dist[u][v] ← w(u,v)  // the weight of the edge (u,v)
   num[u][v] ← 1

for k from 1 to |V|
    for i from 1 to |V|
        for j from 1 to |V|
            if dist[i][j] > dist[i][k] + dist[k][j] 
                dist[i][j] ← dist[i][k] + dist[k][j]
                num[i][j] ← num[i][k] + num[k][j]
            end if

Answer 3

我会尽量给出纯粹的算法答案。

如果从v_1 到v_2 有几条最短路径，其中一些包含v_mid，该怎么办？如果这种情况对于每个(v_1, v_2) 对都计为1，则可以使用Floyd-Warshall 算法。运行后，您将拥有最短路径长度的矩阵。对于每个u，遍历所有(v_1, v_2) 对，如果D[v_1, u] + D[u, v_2] == D[v_1, v_2]，则计算+1。这是 O(n^3) 并且适用于密集图。

我不确定，但我认为可以调整它以计算最短路径的数量。

Answer 4

如果无法进一步访问源代码，就无法肯定地说，但我的赌注是：

S, P, sigma = _single_source_shortest_path_basic(G, s)

或者

betweenness = _rescale(betweenness, len(G),...

重新调整只是听起来就像它会包含一个部门。

你试过用normalized=False调用这个函数吗？