VhF$dZddlmZddlmZmZddlmZddlZ ddl m Z m Z m Z gdZe de jd d Ze de jd d Ze de jd d Zy)zDAlgorithms for finding the lowest common ancestor of trees and DAGs.) defaultdict)MappingSet)combinations_with_replacementN) UnionFindarbitrary_elementnot_implemented_for) all_pairs_lowest_common_ancestor%tree_all_pairs_lowest_common_ancestorlowest_common_ancestor undirectedctj|stjdt|dk(rtjd| t |d}n]t j|}t|}|D]8}t||z stjdt||z d|dd}|||S) aReturn the lowest common ancestor of all pairs or the provided pairs Parameters ---------- G : NetworkX directed graph pairs : iterable of pairs of nodes, optional (default: all pairs) The pairs of nodes of interest. If None, will find the LCA of all pairs of nodes. Yields ------ ((node1, node2), lca) : 2-tuple Where lca is least common ancestor of node1 and node2. Note that for the default case, the order of the node pair is not considered, e.g. you will not get both ``(a, b)`` and ``(b, a)`` Raises ------ NetworkXPointlessConcept If `G` is null. NetworkXError If `G` is not a DAG. Examples -------- >>> from pprint import pprint The default behavior is to yield the lowest common ancestor for all possible combinations of nodes in `G`, including self-pairings: >>> G = nx.DiGraph([(0, 1), (0, 3), (1, 2)]) >>> pprint(dict(nx.all_pairs_lowest_common_ancestor(G))) {(0, 0): 0, (0, 1): 0, (0, 2): 0, (0, 3): 0, (1, 1): 1, (1, 2): 1, (1, 3): 0, (2, 2): 2, (3, 2): 0, (3, 3): 3} The pairs argument can be used to limit the output to only the specified node pairings: >>> dict(nx.all_pairs_lowest_common_ancestor(G, pairs=[(1, 2), (2, 3)])) {(1, 2): 1, (2, 3): 0} Notes ----- Only defined on non-null directed acyclic graphs. See Also -------- lowest_common_ancestor z,LCA only defined on directed acyclic graphs.rLCA meaningless on null graphs.zNode(s) z from pair z not in G.c3Ki}|D]\}}||vr-tj||||<||j|||vr-tj||||<||j|||||z}|svtt |} d}|j |D] }||vs|}n|n|}&||f|fywN)nx ancestorsaddnextiter successors) Gpairsancestor_cachevwcommon_ancestorscommon_ancestor successorlower_ancestors [/home/dcms/DCMS/lib/python3.12/site-packages/networkx/algorithms/lowest_common_ancestors.pygenerate_lca_from_pairszAall_pairs_lowest_common_ancestor..generate_lca_from_pairsas 0DAq&$&LLA$6q!q!%%a(&$&LLA$6q!q!%%a(-a0>!3DD "&t,<'="> $I*+,,*G")-==(6I!"!(&/O1v//+ 0sA:C=/C-C) ris_directed_acyclic_graph NetworkXErrorlenNetworkXPointlessConceptrdictfromkeysset NodeNotFound)rrnodesetpairr#s r"r r sz  ' ' *MNN 1v{))*KLL }-a3 e$a& D4y7"oos4y723;tfJO 04 #1e ,,cltt|||fg}|rt|dk(sJ|ddS|S)agCompute the lowest common ancestor of the given pair of nodes. Parameters ---------- G : NetworkX directed graph node1, node2 : nodes in the graph. default : object Returned if no common ancestor between `node1` and `node2` Returns ------- The lowest common ancestor of node1 and node2, or default if they have no common ancestors. Examples -------- >>> G = nx.DiGraph() >>> nx.add_path(G, (0, 1, 2, 3)) >>> nx.add_path(G, (0, 4, 3)) >>> nx.lowest_common_ancestor(G, 2, 4) 0 See Also -------- all_pairs_lowest_common_ancestor)rr)listr r&)rnode1node2defaultanss r"r r ~sC> /5%.9IJ KC 3x1}}1vay Nr.c#Kt|dk(rtjd|tt}t |t tzs t |}|D]^\}}||fD]*}||vsdt|d}tj|||j|||j|`|m|jD]^\}}|dk(r|d}tj||}'|dkDs-t|j|dkDsId}tj||tjd t} i} |D] } | | | | < tt} tj ||D]} d | | <|| n|D]5}| |s || |f|vr| |f| | |f||| f|vs(|| f| | |f7| |k7sOt#|j| } | j%| | | | | | <yw) aYield the lowest common ancestor for sets of pairs in a tree. Parameters ---------- G : NetworkX directed graph (must be a tree) root : node, optional (default: None) The root of the subtree to operate on. If None, assume the entire graph has exactly one source and use that. pairs : iterable or iterator of pairs of nodes, optional (default: None) The pairs of interest. If None, Defaults to all pairs of nodes under `root` that have a lowest common ancestor. Returns ------- lcas : generator of tuples `((u, v), lca)` where `u` and `v` are nodes in `pairs` and `lca` is their lowest common ancestor. Examples -------- >>> import pprint >>> G = nx.DiGraph([(1, 3), (2, 4), (1, 2)]) >>> pprint.pprint(dict(nx.tree_all_pairs_lowest_common_ancestor(G))) {(1, 1): 1, (2, 1): 1, (2, 2): 2, (3, 1): 1, (3, 2): 1, (3, 3): 3, (3, 4): 1, (4, 1): 1, (4, 2): 2, (4, 4): 4} We can also use `pairs` argument to specify the pairs of nodes for which we want to compute lowest common ancestors. Here is an example: >>> dict(nx.tree_all_pairs_lowest_common_ancestor(G, pairs=[(1, 4), (2, 3)])) {(2, 3): 1, (1, 4): 1} Notes ----- Only defined on non-null trees represented with directed edges from parents to children. Uses Tarjan's off-line lowest-common-ancestors algorithm. Runs in time $O(4 \times (V + E + P))$ time, where 4 is the largest value of the inverse Ackermann function likely to ever come up in actual use, and $P$ is the number of pairs requested (or $V^2$ if all are needed). Tarjan, R. E. (1979), "Applications of path compression on balanced trees", Journal of the ACM 26 (4): 690-715, doi:10.1145/322154.322161. See Also -------- all_pairs_lowest_common_ancestor: similar routine for general DAGs lowest_common_ancestor: just a single pair for general DAGs rrNz The node z is not in the digraph.z0No root specified and tree has multiple sources.r0z0Tree LCA only defined on trees; use DAG routine.zGraph contains a cycle.T)r&rr'rr* isinstancerrstrr+r in_degreer%predrbooldfs_postorder_nodesrunion)rrootr pair_dicturnmsgdegufrnodecolorsparents r"r r sYx 1v{))*KLL $ %3/JE DAqV /A:%c!fX-DEC//#.. / aL  Q  aL  Q    |kk ,FAsax#LC**3//qS^a/H&&s++ , |899 BI#T( $# F&&q$/ +t $)$541 6Aay$$e);)Yr!u%555=QI$6d)Yr!u%555 6 4<&qvvd|4F HHVT "$*Ibj ! +s,A*H-B H7HBHH;H5Hr)NN)__doc__ collectionsrcollections.abcrr itertoolsrnetworkxrnetworkx.utilsrrr __all__ _dispatchabler r r r.r"rQsJ#(3LL \"h-#h-V\"!#!H\"r+#r+r.