查找 NetworkX 中所有节点对之间的所有最短路径

Question

I am trying to get all shortest paths between all pairs of nodes in an undirected unweighted graph. I am currently using nx.all_pairs_shortest_path() , but I don't understand why it only returns one shortest path for every pair of nodes. There are cycles in my graph so there should exist multiple shortest paths between certain nodes. Any suggestions?

Answer 1

Iterate over all nodes in the graph:

results = []
for n1 in G.nodes():
    for n2 in G.nodes():
        shortest_path = nx.single_source_dijkstra(G, source=n1, target=n2, weight=f)
        results.append(shortest_path)
        

Answer 2

I may be late, but I just came across the same problem and this was my solution:

 def all_shortest_paths(G):
    a = list(nx.all_pairs_shortest_path(G))
    all_sp_list = []
    for n in range(len(G.nodes)):
      a1 = a[n][1]
      for k,v in a1.items():
        all_sp_list.append(len(v))
    return all_sp_list

Every other way I tried was getting very very slow because my graph had a bunch of nodes, so this was my fastest solution.

Answer 3

I stumbled upon this problem myself and arrived her in my quest for a solution. unfortunately networkx doesn't have a function to calculate all the shortest pathes for every pair of node. Moreover the answer from Igor Michetti wasn't giving what i wanted at all but it might have been tweekable.

The answer from math_noob was good because it was close enough for me to make up a solution but the problem was that it was way way too slow.

def single_source_shortest_paths(graph,source):
    shortest_paths_dict = {}
    for node in graph:
        shortest_paths_dict[node] = [nx.all_shortest_paths(graph,source,node)]
    return shortest_paths_dict

def all_shortest_paths(graph):
    for source in graph:
        yield source, single_source_shortest_paths(source)

So i went back on networkx documentation and try to find one last time if there was any function i could use. but there was none so i decided i would implment it myself.So i first tried to implement everything by had which was a bit chaotic to only realise that it was a bit better but not that much so i decided i would try to look into the source code and found there a holy grail which is the nx.predecessor function.

This function is called on the graph and the source node only so it doesn't depends on the target node and it is the one doing most of the hard work. So i just recreated the function single_source_shortest_paths but by calling only once nx.predecessor per source node and then doing the same as all_shortest_path which only consist of calling another function with the right arguments.

def single_source_shortest_paths_pred(graph,source):
    shortest_paths_dict = {}
    pred = nx.predecessor(graph,source)
    for node in graph:
        shortest_paths_dict[node] = [nx.algorithms.shortest_paths.generic._build_paths_from_predecessors([source], node, pred)]
    return shortest_paths_dict

In terms of time nx.predecessor takes the majority of the time to execute so the second function is around n times faster where n is the number of nodes in the graph