VhbzdZddlZgdZejdZejdddZejdddZejddd Zejddd Z ejddd Z ejddd Z d Z y)z Compute the shortest paths and path lengths between nodes in the graph. These algorithms work with undirected and directed graphs. N) shortest_pathall_shortest_paths single_source_all_shortest_pathsall_pairs_all_shortest_pathsshortest_path_lengthaverage_shortest_path_lengthhas_pathcf tj|||y#tj$rYywxYw)zReturns *True* if *G* has a path from *source* to *target*. Parameters ---------- G : NetworkX graph source : node Starting node for path target : node Ending node for path FT)nxrNetworkXNoPath)Gsourcetargets Z/home/dcms/DCMS/lib/python3.12/site-packages/networkx/algorithms/shortest_paths/generic.pyr r s8 FF+    s 00weight) edge_attrscr|dvrtd||dn|}||S|dk(rtj|}|S|dk(rtj||}|Stj||}|S|j r|j d}|dk(rtj||}n6|dk(rtj|||}ntj|||}|D]}tt||||<|S|V|dk(rtj||}|S|dk(rtj|||}|Stj|||}|S|dk(rtj|||}|S|dk(rtj||||\}}|Stj||||}|S)a* Compute shortest paths in the graph. Parameters ---------- G : NetworkX graph source : node, optional Starting node for path. If not specified, compute shortest paths for each possible starting node. target : node, optional Ending node for path. If not specified, compute shortest paths to all possible nodes. weight : None, string or function, optional (default = None) If None, every edge has weight/distance/cost 1. If a string, use this edge attribute as the edge weight. Any edge attribute not present defaults to 1. If this is a function, the weight of an edge is the value returned by the function. The function must accept exactly three positional arguments: the two endpoints of an edge and the dictionary of edge attributes for that edge. The function must return a number. method : string, optional (default = 'dijkstra') The algorithm to use to compute the path. Supported options: 'dijkstra', 'bellman-ford'. Other inputs produce a ValueError. If `weight` is None, unweighted graph methods are used, and this suggestion is ignored. Returns ------- path: list or dictionary or iterator All returned paths include both the source and target in the path. If the source and target are both specified, return a single list of nodes in a shortest path from the source to the target. If only the source is specified, return a dictionary keyed by targets with a list of nodes in a shortest path from the source to one of the targets. If only the target is specified, return a dictionary keyed by sources with a list of nodes in a shortest path from one of the sources to the target. If neither the source nor target are specified, return an iterator over (source, dictionary) where dictionary is keyed by target to list of nodes in a shortest path from the source to the target. Raises ------ NodeNotFound If `source` is not in `G`. ValueError If `method` is not among the supported options. Examples -------- >>> G = nx.path_graph(5) >>> print(nx.shortest_path(G, source=0, target=4)) [0, 1, 2, 3, 4] >>> p = nx.shortest_path(G, source=0) # target not specified >>> p[3] # shortest path from source=0 to target=3 [0, 1, 2, 3] >>> p = nx.shortest_path(G, target=4) # source not specified >>> p[1] # shortest path from source=1 to target=4 [1, 2, 3, 4] >>> p = dict(nx.shortest_path(G)) # source, target not specified >>> p[2][4] # shortest path from source=2 to target=4 [2, 3, 4] Notes ----- There may be more than one shortest path between a source and target. This returns only one of them. See Also -------- all_pairs_shortest_path all_pairs_dijkstra_path all_pairs_bellman_ford_path single_source_shortest_path single_source_dijkstra_path single_source_bellman_ford_path dijkstra bellman-fordmethod not supported: unweightedrrFcopy) ValueErrorr all_pairs_shortest_pathall_pairs_dijkstra_pathall_pairs_bellman_ford_path is_directedreversesingle_source_shortest_pathsingle_source_dijkstra_pathsingle_source_bellman_ford_pathlistreversedbidirectional_shortest_pathbidirectional_dijkstrabellman_ford_path)r rrrmethodpaths_s rrr*st111&:;;#^\F ~ >%2215F LE:%221VDB L?66qH> L9}}II5I)%66q&A:%66q&P::1fVT > $XeFm%< =f  >& L! >%66q&A L:%66q&P L::1fVT L %66q&&I L :%44QO5 L,,QG Lch|dvrtd||dn|}||S|dk(rtj|}|S|dk(rtj||}|Stj||}|S|j r|j d}|dk(rtj}|||}|S|dk(rtj}||||}|Stj}||||}|S|\|dk(rtj||}|S|dk(rtj}||||}|Stj}||||}|S|dk(r'tj|||}t|dz }|S|dk(rtj||||}|Stj||||}|S) af Compute shortest path lengths in the graph. Parameters ---------- G : NetworkX graph source : node, optional Starting node for path. If not specified, compute shortest path lengths using all nodes as source nodes. target : node, optional Ending node for path. If not specified, compute shortest path lengths using all nodes as target nodes. weight : None, string or function, optional (default = None) If None, every edge has weight/distance/cost 1. If a string, use this edge attribute as the edge weight. Any edge attribute not present defaults to 1. If this is a function, the weight of an edge is the value returned by the function. The function must accept exactly three positional arguments: the two endpoints of an edge and the dictionary of edge attributes for that edge. The function must return a number. method : string, optional (default = 'dijkstra') The algorithm to use to compute the path length. Supported options: 'dijkstra', 'bellman-ford'. Other inputs produce a ValueError. If `weight` is None, unweighted graph methods are used, and this suggestion is ignored. Returns ------- length: number or iterator If the source and target are both specified, return the length of the shortest path from the source to the target. If only the source is specified, return a dict keyed by target to the shortest path length from the source to that target. If only the target is specified, return a dict keyed by source to the shortest path length from that source to the target. If neither the source nor target are specified, return an iterator over (source, dictionary) where dictionary is keyed by target to shortest path length from source to that target. Raises ------ NodeNotFound If `source` is not in `G`. NetworkXNoPath If no path exists between source and target. ValueError If `method` is not among the supported options. Examples -------- >>> G = nx.path_graph(5) >>> nx.shortest_path_length(G, source=0, target=4) 4 >>> p = nx.shortest_path_length(G, source=0) # target not specified >>> p[4] 4 >>> p = nx.shortest_path_length(G, target=4) # source not specified >>> p[0] 4 >>> p = dict(nx.shortest_path_length(G)) # source,target not specified >>> p[0][4] 4 Notes ----- The length of the path is always 1 less than the number of nodes involved in the path since the length measures the number of edges followed. For digraphs this returns the shortest directed path length. To find path lengths in the reverse direction use G.reverse(copy=False) first to flip the edge orientation. See Also -------- all_pairs_shortest_path_length all_pairs_dijkstra_path_length all_pairs_bellman_ford_path_length single_source_shortest_path_length single_source_dijkstra_path_length single_source_bellman_ford_path_length rrrrrFr)rr all_pairs_shortest_path_lengthall_pairs_dijkstra_path_length"all_pairs_bellman_ford_path_lengthr r!"single_source_shortest_path_length"single_source_dijkstra_path_length&single_source_bellman_ford_path_lengthr'lendijkstra_path_lengthbellman_ford_path_length)r rrrr*r+ path_lengthps rrrs~111&:;;#^\F ~ >%99!<L LK:%99!FKH LE==aOD L?}}II5I)% CC #Av.6 L5:% CC #Avf=0 L-!GG #Avf=* L' >%==aH L:% CC #Avf= L!GG #Avf= L%221ffEA  L :%//666J L33AvvvN Lr-c gd}ddg}||z}dnd|vrtdt}|dk(rd}tj||d k(ryj r*tj stj d j s*tjstj d fd  |vrt fd D}npdk(r8tj} td| jD}n3dk(r.ttjj}||d z zz S)aoReturns the average shortest path length. The average shortest path length is .. math:: a =\sum_{\substack{s,t \in V \\ s\neq t}} \frac{d(s, t)}{n(n-1)} where `V` is the set of nodes in `G`, `d(s, t)` is the shortest path from `s` to `t`, and `n` is the number of nodes in `G`. .. versionchanged:: 3.0 An exception is raised for directed graphs that are not strongly connected. Parameters ---------- G : NetworkX graph weight : None, string or function, optional (default = None) If None, every edge has weight/distance/cost 1. If a string, use this edge attribute as the edge weight. Any edge attribute not present defaults to 1. If this is a function, the weight of an edge is the value returned by the function. The function must accept exactly three positional arguments: the two endpoints of an edge and the dictionary of edge attributes for that edge. The function must return a number. method : string, optional (default = 'unweighted' or 'dijkstra') The algorithm to use to compute the path lengths. Supported options are 'unweighted', 'dijkstra', 'bellman-ford', 'floyd-warshall' and 'floyd-warshall-numpy'. Other method values produce a ValueError. The default method is 'unweighted' if `weight` is None, otherwise the default method is 'dijkstra'. Raises ------ NetworkXPointlessConcept If `G` is the null graph (that is, the graph on zero nodes). NetworkXError If `G` is not connected (or not strongly connected, in the case of a directed graph). ValueError If `method` is not among the supported options. Examples -------- >>> G = nx.path_graph(5) >>> nx.average_shortest_path_length(G) 2.0 For disconnected graphs, you can compute the average shortest path length for each component >>> G = nx.Graph([(1, 2), (3, 4)]) >>> for C in (G.subgraph(c).copy() for c in nx.connected_components(G)): ... print(nx.average_shortest_path_length(C)) 1.0 1.0 )rrrzfloyd-warshallzfloyd-warshall-numpyrrrrzJthe null graph has no paths, thus there is no average shortest path lengthr/z Graph is not strongly connected.zGraph is not connected.cdk(rtj|Sdk(rtj|Sdk(rtj|Sy)Nrrrr)r r3r4r5)vr r*rs rr9z1average_shortest_path_length..path_lengths] \ !88A> > z !88AfM M ~ %<z/average_shortest_path_length..s*>ak!n&;&;&=>>>s'*rc3NK|]}t|jywr?)sumr@)rAts rrDz/average_shortest_path_length..s@C O@s#%) rr6r NetworkXPointlessConceptr is_strongly_connected NetworkXError is_connectedrFfloyd_warshallr@floatfloyd_warshall_numpy) r rr*single_source_methodsall_pairs_methodssupported_methodsnmsgs all_pairsr9s ``` @rrrBsgHG)+AB-0AA ~!'Z &&1&:;; AA Av X ))#..Av}}r77:ABB ==?2??1#5899R&& >1> > % %))!F;I@Y-=-=-?@@A - -b--a?CCEFA QU r-c|dn|}|dk(rtj||}nP|dk(rtj|||\}}n/|dk(rtj|||\}}nt d|t |h||S)aCompute all shortest simple paths in the graph. Parameters ---------- G : NetworkX graph source : node Starting node for path. target : node Ending node for path. weight : None, string or function, optional (default = None) If None, every edge has weight/distance/cost 1. If a string, use this edge attribute as the edge weight. Any edge attribute not present defaults to 1. If this is a function, the weight of an edge is the value returned by the function. The function must accept exactly three positional arguments: the two endpoints of an edge and the dictionary of edge attributes for that edge. The function must return a number. method : string, optional (default = 'dijkstra') The algorithm to use to compute the path lengths. Supported options: 'dijkstra', 'bellman-ford'. Other inputs produce a ValueError. If `weight` is None, unweighted graph methods are used, and this suggestion is ignored. Returns ------- paths : generator of lists A generator of all paths between source and target. Raises ------ ValueError If `method` is not among the supported options. NetworkXNoPath If `target` cannot be reached from `source`. Examples -------- >>> G = nx.Graph() >>> nx.add_path(G, [0, 1, 2]) >>> nx.add_path(G, [0, 10, 2]) >>> print([p for p in nx.all_shortest_paths(G, source=0, target=2)]) [[0, 1, 2], [0, 10, 2]] Notes ----- There may be many shortest paths between the source and target. If G contains zero-weight cycles, this function will not produce all shortest paths because doing so would produce infinitely many paths of unbounded length -- instead, we only produce the shortest simple paths. See Also -------- shortest_path single_source_shortest_path all_pairs_shortest_path rrrrr)r predecessor!dijkstra_predecessor_and_distance%bellman_ford_predecessor_and_distancer_build_paths_from_predecessors)r rrrr*preddists rrrsB$^\F ~~a( : 99!VFS d > !==aPVW d1&:;; )6(FD AAr-c #4K|dn|}|dk(rtj||}nP|dk(rtj|||\}}n/|dk(rtj|||\}}nt d||D]}|t t |h||fyw)aCompute all shortest simple paths from the given source in the graph. Parameters ---------- G : NetworkX graph source : node Starting node for path. weight : None, string or function, optional (default = None) If None, every edge has weight/distance/cost 1. If a string, use this edge attribute as the edge weight. Any edge attribute not present defaults to 1. If this is a function, the weight of an edge is the value returned by the function. The function must accept exactly three positional arguments: the two endpoints of an edge and the dictionary of edge attributes for that edge. The function must return a number. method : string, optional (default = 'dijkstra') The algorithm to use to compute the path lengths. Supported options: 'dijkstra', 'bellman-ford'. Other inputs produce a ValueError. If `weight` is None, unweighted graph methods are used, and this suggestion is ignored. Returns ------- paths : generator of dictionary A generator of all paths between source and all nodes in the graph. Raises ------ ValueError If `method` is not among the supported options. Examples -------- >>> G = nx.Graph() >>> nx.add_path(G, [0, 1, 2, 3, 0]) >>> dict(nx.single_source_all_shortest_paths(G, source=0)) {0: [[0]], 1: [[0, 1]], 3: [[0, 3]], 2: [[0, 1, 2], [0, 3, 2]]} Notes ----- There may be many shortest paths between the source and target. If G contains zero-weight cycles, this function will not produce all shortest paths because doing so would produce infinitely many paths of unbounded length -- instead, we only produce the shortest simple paths. See Also -------- shortest_path all_shortest_paths single_source_shortest_path all_pairs_shortest_path all_pairs_all_shortest_paths Nrrrrr)r rWrXrYrr%rZ)r rrr*r[r\rRs rrrsx$^\F ~~a( : 99!VFS d > !==aPVW d1&:;; I4fXq$GHHHIsBBc #RK|D]}|tt||||f yw)aqCompute all shortest paths between all nodes. Parameters ---------- G : NetworkX graph weight : None, string or function, optional (default = None) If None, every edge has weight/distance/cost 1. If a string, use this edge attribute as the edge weight. Any edge attribute not present defaults to 1. If this is a function, the weight of an edge is the value returned by the function. The function must accept exactly three positional arguments: the two endpoints of an edge and the dictionary of edge attributes for that edge. The function must return a number. method : string, optional (default = 'dijkstra') The algorithm to use to compute the path lengths. Supported options: 'dijkstra', 'bellman-ford'. Other inputs produce a ValueError. If `weight` is None, unweighted graph methods are used, and this suggestion is ignored. Returns ------- paths : generator of dictionary Dictionary of arrays, keyed by source and target, of all shortest paths. Raises ------ ValueError If `method` is not among the supported options. Examples -------- >>> G = nx.cycle_graph(4) >>> dict(nx.all_pairs_all_shortest_paths(G))[0][2] [[0, 1, 2], [0, 3, 2]] >>> dict(nx.all_pairs_all_shortest_paths(G))[0][3] [[0, 3]] Notes ----- There may be multiple shortest paths with equal lengths. Unlike all_pairs_shortest_path, this method returns all shortest paths. See Also -------- all_pairs_shortest_path single_source_all_shortest_paths )rr*N)dictr)r rr*rRs rrrMs9j  1!QvfU V   s%'c#K||vrtjd|d|h}|dgg}d}|dk\r||\}}||vr&t|d|dzD cgc]\}} | c} }t|||kDr[|dz||d<|||} | |vr`|j | |dz }|t|k(r|j | dgn!| dg||ddn|j ||dz}|dk\ryycc} }ww)aCompute all simple paths to target, given the predecessors found in pred, terminating when any source in sources is found. Parameters ---------- sources : set Starting nodes for path. target : node Ending node for path. pred : dict A dictionary of predecessor lists, keyed by node Returns ------- paths : generator of lists A generator of all paths between source and target. Raises ------ NetworkXNoPath If `target` cannot be reached from `source`. Notes ----- There may be many paths between the sources and target. If there are cycles among the predecessors, this function will not produce all possible paths because doing so would produce infinitely many paths of unbounded length -- instead, we only produce simple paths. See Also -------- shortest_path single_source_shortest_path all_pairs_shortest_path all_shortest_paths bellman_ford_path zTarget z% cannot be reached from given sourcesrNr/)r r r&r6addappenddiscard) sourcesrr[seenstacktopnodeir:rRnexts rrZrZsPT'&1V WXX 8Da[ME C (*a 7?!)% #'*:!;<A1< < tDz?Q EE#JqM:a=Dt| 1HCc%j  dAY'!%q c 1 LL  1HC% (=sA C1 C+B C1)C1)NNNr)NN)Nr) __doc__networkxr __all__ _dispatchabler rrrrrrrZr-rrps (X&D'DNX&L'L^X&p'pfX&JB'JBZX&EI'EIPX&8 '8 v@r-