Vh<XdZddlZgdZejddZdZejddZejddZejdZ d Z ejdd Z d Z ejdd Z ejdd ZejddZy)z1 Shortest path algorithms for unweighted graphs. N)bidirectional_shortest_pathsingle_source_shortest_path"single_source_shortest_path_lengthsingle_target_shortest_path"single_target_shortest_path_lengthall_pairs_shortest_pathall_pairs_shortest_path_length predecessorc||vrtjd|d| td}|g}tt |j ||S)aCompute the shortest path lengths from `source` to all reachable nodes in `G`. Parameters ---------- G : NetworkX graph source : node Starting node for path cutoff : integer, optional Depth to stop the search. Only paths of length <= `cutoff` are returned. Returns ------- lengths : dict Dict keyed by node to shortest path length to `source`. Examples -------- >>> G = nx.path_graph(5) >>> nx.single_source_shortest_path_length(G, 0) {0: 0, 1: 1, 2: 2, 3: 3, 4: 4} See Also -------- :any:`shortest_path_length` : Shortest path length with specifiable source, target, and weight. :any:`single_source_dijkstra_path_length` : Shortest weighted path length from source with Dijkstra algorithm. :any:`single_source_bellman_ford_path_length` : Shortest weighted path length from source with Bellman-Ford algorithm. Source is not in Ginf)nx NodeNotFoundfloatdict_single_shortest_path_length_adj)Gsourcecutoff nextlevels ]/home/dcms/DCMS/lib/python3.12/site-packages/networkx/algorithms/shortest_paths/unweighted.pyrrsRDQoox|<== ~uI ,QVVYG HHc#,Kt|}|}d}t|}|D]}||f |rg||kDra|dz }|}g}|D]I}||D]/} | |vs|j| |j| | |f1t||k(sIy|r||kDr_yyyyw)aNYields (node, level) in a breadth first search Shortest Path Length helper function Parameters ---------- adj : dict Adjacency dict or view firstlevel : list starting nodes, e.g. [source] or [target] cutoff : int or float level at which we stop the process rN)setlenaddappend) adj firstlevelrseenrlevelnv thislevelws rrr=s z?DI E CA %j      AV %D=HHQK$$Q'e*$  % 4yA~  ))sA B 8B BBc||vrtjd|d| td}|jr |jn |j }|g}t t|||S)aCompute the shortest path lengths to target from all reachable nodes. Parameters ---------- G : NetworkX graph target : node Target node for path cutoff : integer, optional Depth to stop the search. Only paths of length <= cutoff are returned. Returns ------- lengths : dictionary Dictionary, keyed by source, of shortest path lengths. Examples -------- >>> G = nx.path_graph(5, create_using=nx.DiGraph()) >>> length = nx.single_target_shortest_path_length(G, 4) >>> length[0] 4 >>> for node in range(5): ... print(f"{node}: {length[node]}") 0: 4 1: 3 2: 2 3: 1 4: 0 See Also -------- single_source_shortest_path_length, shortest_path_length Target r r)rrr is_directed_predrrr)rtargetrr!rs rrr^seJQoox|<== ~u]]_!''!&&CI ,S)VD EErc#DKt}|D]}|||||fyw)a:Computes the shortest path lengths between all nodes in `G`. Parameters ---------- G : NetworkX graph cutoff : integer, optional Depth at which to stop the search. Only paths of length at most `cutoff` are returned. Returns ------- lengths : iterator (source, dictionary) iterator with dictionary keyed by target and shortest path length as the key value. Notes ----- The iterator returned only has reachable node pairs. Examples -------- >>> G = nx.path_graph(5) >>> length = dict(nx.all_pairs_shortest_path_length(G)) >>> for node in [0, 1, 2, 3, 4]: ... print(f"1 - {node}: {length[1][node]}") 1 - 0: 1 1 - 1: 0 1 - 2: 1 1 - 3: 2 1 - 4: 3 >>> length[3][2] 1 >>> length[2][2] 0 rN)r)rrlengthr%s rr r s1N0F /&Af-../s c@||vrtjd|d||vrtjd|dt|||}|\}}}g}||j|||}||j ||d}||j|||}||S)aReturns a list of nodes in a shortest path between source and target. Parameters ---------- G : NetworkX graph source : node label starting node for path target : node label ending node for path Returns ------- path: list List of nodes in a path from source to target. Raises ------ NetworkXNoPath If no path exists between source and target. Examples -------- >>> G = nx.Graph() >>> nx.add_path(G, [0, 1, 2, 3, 0, 4, 5, 6, 7, 4]) >>> nx.bidirectional_shortest_path(G, 2, 6) [2, 1, 0, 4, 5, 6] See Also -------- shortest_path Notes ----- This algorithm is used by shortest_path(G, source, target). r r r*)rr_bidirectional_pred_succr reverse)rrr-resultspredsuccr(paths rrrsPQoox|<== Qoox|<=='q&&9GMD$ D - A G - LLN T"XA - A G - Krc&||k(r |di|di|fS|jr|j}|j}n|j}|j}|di}|di}|g}|g}|r|rt |t |kr=|} g}| D]3} || D])} | |vr|j | | || <| |vs"||| fccS5n<|} g}| D]3} || D])} | |vr| || <|j | | |vs"||| fccS5|r|rt jd|d|d)zBidirectional shortest path helper. Returns (pred, succ, w) where pred is a dictionary of predecessors from w to the source, and succ is a dictionary of successors from w to the target. NzNo path between z and .)r+r6r7r!rr rNetworkXNoPath) rrr-GpredGsuccr6r7forward_fringereverse_fringe this_levelr&r(s rr3r3sq77 }} D>D D>DXNXN ^ ~ #n"5 5'JN -q-A}&--a0"#QDy#T1}, - -(JN -q-A}"#Q&--a0Dy#T1}, - - ^,  .vheF81E FFrc ||vrtjd|dd}| td}|di}||gi}tt |j ||||S)afCompute shortest path between source and all other nodes reachable from source. Parameters ---------- G : NetworkX graph source : node label Starting node for path cutoff : integer, optional Depth to stop the search. Only paths of length <= cutoff are returned. Returns ------- paths : dictionary Dictionary, keyed by target, of shortest paths. Examples -------- >>> G = nx.path_graph(5) >>> path = nx.single_source_shortest_path(G, 0) >>> path[4] [0, 1, 2, 3, 4] Notes ----- The shortest path is not necessarily unique. So there can be multiple paths between the source and each target node, all of which have the same 'shortest' length. For each target node, this function returns only one of those paths. See Also -------- shortest_path r not in Gc ||zSNp1p2s rjoinz)single_source_shortest_path..joinY Bwrrr)rrrr_single_shortest_pathr!)rrrrIrpathss rrr0skLQooxy9::~u I fX E %aeeYvtL MMrcd}|}|rA||kDr<|}i}|D]&}||D]} | |vs|||| g|| <d|| <(|dz }|r||kDr<|S)aReturns shortest paths Shortest Path helper function Parameters ---------- adj : dict Adjacency dict or view firstlevel : dict starting nodes, e.g. {source: 1} or {target: 1} paths : dict paths for starting nodes, e.g. {source: [source]} cutoff : int or float level at which we stop the process join : function function to construct a path from two partial paths. Requires two list inputs `p1` and `p2`, and returns a list. Usually returns `p1 + p2` (forward from source) or `p2 + p1` (backward from target) rrrE) r!r"rLrrIr$rr'r&r(s rrKrKcs& EI    %AV %E>#E!Hqc2E!H#$IaL % %    Lrc ||vrtjd|dd}|jr |jn |j}| t d}|di}||gi}t t|||||S)aCompute shortest path to target from all nodes that reach target. Parameters ---------- G : NetworkX graph target : node label Target node for path cutoff : integer, optional Depth to stop the search. Only paths of length <= cutoff are returned. Returns ------- paths : dictionary Dictionary, keyed by target, of shortest paths. Examples -------- >>> G = nx.path_graph(5, create_using=nx.DiGraph()) >>> path = nx.single_target_shortest_path(G, 4) >>> path[0] [0, 1, 2, 3, 4] Notes ----- The shortest path is not necessarily unique. So there can be multiple paths between the source and each target node, all of which have the same 'shortest' length. For each target node, this function returns only one of those paths. See Also -------- shortest_path, single_source_shortest_path r*rBc ||zSrDrErFs rrIz)single_target_shortest_path..joinrJrrr)rrr+r6r!rrrK)rr-rrIr!rrLs rrrs~JQooxy9::MMO!&&C ~u I fX E %c9eVTJ KKrc#>K|D]}|t|||fyw)aCompute shortest paths between all nodes. Parameters ---------- G : NetworkX graph cutoff : integer, optional Depth at which to stop the search. Only paths of length at most `cutoff` are returned. Returns ------- paths : iterator Dictionary, keyed by source and target, of shortest paths. Examples -------- >>> G = nx.path_graph(5) >>> path = dict(nx.all_pairs_shortest_path(G)) >>> print(path[0][4]) [0, 1, 2, 3, 4] Notes ----- There may be multiple shortest paths with the same length between two nodes. For each pair, this function returns only one of those paths. See Also -------- floyd_warshall all_pairs_all_shortest_paths r/N)r)rrr%s rrrs/HD-a6BCCDscr||vrtjd|dd}|g}||i}|gi}|rc|dz}|} g}| D]J} || D]@} | |vr| g|| <||| <|j| $|| |k(s-|| j| BL|r||krn|rc||r||vrgdfS||||fS||vrgS||S|r||fS|S)aReturns dict of predecessors for the path from source to all nodes in G. Parameters ---------- G : NetworkX graph source : node label Starting node for path target : node label, optional Ending node for path. If provided only predecessors between source and target are returned cutoff : integer, optional Depth to stop the search. Only paths of length <= cutoff are returned. return_seen : bool, optional (default=None) Whether to return a dictionary, keyed by node, of the level (number of hops) to reach the node (as seen during breadth-first-search). Returns ------- pred : dictionary Dictionary, keyed by node, of predecessors in the shortest path. (pred, seen): tuple of dictionaries If `return_seen` argument is set to `True`, then a tuple of dictionaries is returned. The first element is the dictionary, keyed by node, of predecessors in the shortest path. The second element is the dictionary, keyed by node, of the level (number of hops) to reach the node (as seen during breadth-first-search). Examples -------- >>> G = nx.path_graph(4) >>> list(G) [0, 1, 2, 3] >>> nx.predecessor(G, 0) {0: [], 1: [0], 2: [1], 3: [2]} >>> nx.predecessor(G, 0, return_seen=True) ({0: [], 1: [0], 2: [1], 3: [2]}, {0: 0, 1: 1, 2: 2, 3: 3}) r rBrrr2)rrr ) rrr-r return_seenr$rr#r6r'r&r(s rr r s*^Qooxy9:: EI E?D BrWs  &I&IRB+F+F\)/)/X>>B1Gh/N/NdB0L0Lf$D$DNQQr