hSrSSKrSSKrSSKJrJr SSKrSSK J r J r /SQr \ "S5\ "S5\RS555r\ "S5\ "S5\RS 555r\ "S5\ "S5\RSS j555r\RS S j5r\ "S5\ "S5\RSS j555r\ "S5\ "S5\RS!S j555rSrS!Sjr\"SS5rSr\RS5r\RS"Sj5r\RS5r\RS Sj5rSr\R"SS9S5r\RS5rSr\ "S5\ "S5\ "S5\RS#Sj5555r g)$a Algorithms for finding k-edge-augmentations A k-edge-augmentation is a set of edges, that once added to a graph, ensures that the graph is k-edge-connected; i.e. the graph cannot be disconnected unless k or more edges are removed. Typically, the goal is to find the augmentation with minimum weight. In general, it is not guaranteed that a k-edge-augmentation exists. See Also -------- :mod:`edge_kcomponents` : algorithms for finding k-edge-connected components :mod:`connectivity` : algorithms for determining edge connectivity. N) defaultdict namedtuple)not_implemented_forpy_random_state)k_edge_augmentationis_k_edge_connectedis_locally_k_edge_connecteddirected multigraphc^TS:a[ST35eUR5TS-:ag[U4SjUR555(agTS:Xa[R "U5$TS:Xa8[R "U5=(a [R "U5(+$[R"UTS9T:$)aTests to see if a graph is k-edge-connected. Is it impossible to disconnect the graph by removing fewer than k edges? If so, then G is k-edge-connected. Parameters ---------- G : NetworkX graph An undirected graph. k : integer edge connectivity to test for Returns ------- boolean True if G is k-edge-connected. See Also -------- :func:`is_locally_k_edge_connected` Examples -------- >>> G = nx.barbell_graph(10, 0) >>> nx.is_k_edge_connected(G, k=1) True >>> nx.is_k_edge_connected(G, k=2) False k must be positive, not Fc32># UH upUT:v M g7fN).0ndks d/var/www/html/env/lib/python3.13/site-packages/networkx/algorithms/connectivity/edge_augmentation.py &is_k_edge_connected..As *ztqQUzscutoff) ValueErrornumber_of_nodesanydegreenx is_connected has_bridgesedge_connectivity)Grs `rrrsD 1u3A3788QU" *qxxz * * * 6??1% % !V??1%?bnnQ.?*? ?''!49 9cUS:a[SU35eURU5U:dURU5U:agUS:Xa[R"XU5$[RR XX#S9nXC:$)a Tests to see if an edge in a graph is locally k-edge-connected. Is it impossible to disconnect s and t by removing fewer than k edges? If so, then s and t are locally k-edge-connected in G. Parameters ---------- G : NetworkX graph An undirected graph. s : node Source node t : node Target node k : integer local edge connectivity for nodes s and t Returns ------- boolean True if s and t are locally k-edge-connected in G. See Also -------- :func:`is_k_edge_connected` Examples -------- >>> from networkx.algorithms.connectivity import is_locally_k_edge_connected >>> G = nx.barbell_graph(10, 0) >>> is_locally_k_edge_connected(G, 5, 15, k=1) True >>> is_locally_k_edge_connected(G, 5, 15, k=2) False >>> is_locally_k_edge_connected(G, 1, 5, k=2) True r rFr)rrr has_path connectivitylocal_edge_connectivity)r$strlocalks rr r Ms|V 1u3A3788 xx{Q!((1+/ 6;;qQ' '__<3, this problem is NP-hard and this uses a randomized algorithm that produces a feasible solution, but provides no guarantees on the solution weight. Examples -------- >>> # Unweighted cases >>> G = nx.path_graph((1, 2, 3, 4)) >>> G.add_node(5) >>> sorted(nx.k_edge_augmentation(G, k=1)) [(1, 5)] >>> sorted(nx.k_edge_augmentation(G, k=2)) [(1, 5), (5, 4)] >>> sorted(nx.k_edge_augmentation(G, k=3)) [(1, 4), (1, 5), (2, 5), (3, 5), (4, 5)] >>> complement = list(nx.k_edge_augmentation(G, k=5, partial=True)) >>> G.add_edges_from(complement) >>> nx.edge_connectivity(G) 4 >>> # Weighted cases >>> G = nx.path_graph((1, 2, 3, 4)) >>> G.add_node(5) >>> # avail can be a tuple with a dict >>> avail = [(1, 5, {"weight": 11}), (2, 5, {"weight": 10})] >>> sorted(nx.k_edge_augmentation(G, k=1, avail=avail, weight="weight")) [(2, 5)] >>> # or avail can be a 3-tuple with a real number >>> avail = [(1, 5, 11), (2, 5, 10), (4, 3, 1), (4, 5, 51)] >>> sorted(nx.k_edge_augmentation(G, k=2, avail=avail)) [(1, 5), (2, 5), (4, 5)] >>> # or avail can be a dict >>> avail = {(1, 5): 11, (2, 5): 10, (4, 3): 1, (4, 5): 51} >>> sorted(nx.k_edge_augmentation(G, k=2, avail=avail)) [(1, 5), (2, 5), (4, 5)] >>> # If augmentation is infeasible, then a partial solution can be found >>> avail = {(1, 5): 11} >>> sorted(nx.k_edge_augmentation(G, k=2, avail=avail, partial=True)) [(1, 5)] rz"k must be a positive integer, not r zimpossible to z! connect in graph with less than z nodesNzno available edgesavailweightpartialrr/r0)rr/r0seed)rr/r0) rrr NetworkXUnfeasiblelenrone_edge_augmentationbridge_augmentationgreedy_k_edge_augmentationlistcomplement_edgespartial_k_edge_augmentation)r$rr/r0r1msg aug_edgess rrrs.b% 6A!EF F    1q5 ("1#%Fq1ugVTC'', ,  3u:?))!//++,@AAI !V-vI!V+A6JI3eI  ?""  },Q/ 8% !  sGD CCCCD C9DDDD DD c ## Sn[X#US9upVUR5nURS[X&555 [ [ R "XqS95nUHn [U 5S:dMURU 5R5n U RSS9V V V s0sHupn SU ;dMU SU S _M nn n n U RUR55 [ R"XUS 9S hvN M [R"US 5HDunnU"XU5H1upURX5n U R!SS 5nUcM-Uv M3 MF g s sn n n fNo7f) aFinds augmentation that k-edge-connects as much of the graph as possible. When a k-edge-augmentation is not possible, we can still try to find a small set of edges that partially k-edge-connects as much of the graph as possible. All possible edges are generated between remaining parts. This minimizes the number of k-edge-connected subgraphs in the resulting graph and maximizes the edge connectivity between those subgraphs. Parameters ---------- G : NetworkX graph An undirected graph. k : integer Desired edge connectivity avail : dict or a set of 2 or 3 tuples For more details, see :func:`k_edge_augmentation`. weight : string key to use to find weights if ``avail`` is a set of 3-tuples. For more details, see :func:`k_edge_augmentation`. Yields ------ edge : tuple Edges in the partial augmentation of G. These edges k-edge-connect any part of G where it is possible, and maximally connects the remaining parts. In other words, all edges from avail are generated except for those within subgraphs that have already become k-edge-connected. Notes ----- Construct H that augments G with all edges in avail. Find the k-edge-subgraphs of H. For each k-edge-subgraph, if the number of nodes is more than k, then find the k-edge-augmentation of that graph and add it to the solution. Then add all edges in avail between k-edge subgraphs to the solution. See Also -------- :func:`k_edge_augmentation` Examples -------- >>> G = nx.path_graph((1, 2, 3, 4, 5, 6, 7)) >>> G.add_node(8) >>> avail = [(1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (3, 5), (1, 8)] >>> sorted(partial_k_edge_augmentation(G, k=2, avail=avail)) [(1, 5), (1, 8)] c3# UVs0sHo3[URU5_M nnUR5H$up5URU5nUHnX74v M M& gs snf7f)z"finds edges between disjoint nodesN)setadjitems intersection)Honly1only2u only1_adjneighbs neighbs12vs r_edges_between_disjoint._edges_between_disjointVsa/45u!AEE!H %u 5#//+JA,,U3If ,6sA)"A$AA)r0r$c3<# UHuupnXX1U4S.4v M g7fr0 generatorNr)rrGrKws rr.partial_k_edge_augmentation..ds) 0 a!f5 60srr TdatarRr0)rr/Nr)_unpack_available_edgescopyadd_edges_fromzipr9r k_edge_subgraphsr5subgraphedgesremove_edges_fromkeysrit combinations get_edge_dataget)r$rr/r0rLavail_uvavail_wrDr\nodesCrGrKr sub_availcc1cc2edges rr;r; sil0JH A  0  B//78" u:> 5!&&(A"#d!3!3IQ1!#,+( +!3      0 1--aIF F F""OO$4a8S+AC8DA%A55d+D 99 Gs1A0E362E3( E* 9 E* ;E3E1AE3E3c2Uc [U5$[XX#S9$)aFinds minimum weight set of edges to connect G. Equivalent to :func:`k_edge_augmentation` when k=1. Adding the resulting edges to G will make it 1-edge-connected. The solution is optimal for both weighted and non-weighted variants. Parameters ---------- G : NetworkX graph An undirected graph. avail : dict or a set of 2 or 3 tuples For more details, see :func:`k_edge_augmentation`. weight : string key to use to find weights if ``avail`` is a set of 3-tuples. For more details, see :func:`k_edge_augmentation`. partial : boolean If partial is True and no feasible k-edge-augmentation exists, then the augmenting edges minimize the number of connected components. Yields ------ edge : tuple Edges in the one-augmentation of G Raises ------ NetworkXUnfeasible If partial is False and no one-edge-augmentation exists. Notes ----- Uses either :func:`unconstrained_one_edge_augmentation` or :func:`weighted_one_edge_augmentation` depending on whether ``avail`` is specified. Both algorithms are based on finding a minimum spanning tree. As such both algorithms find optimal solutions and run in linear time. See Also -------- :func:`k_edge_augmentation` r.)#unconstrained_one_edge_augmentationweighted_one_edge_augmentation)r$r/r0r1s rr6r6s'^ }2155- 6  r%cUR5S:a[R"S5eUc [U5$[ XUS9$)aFinds the a set of edges that bridge connects G. Equivalent to :func:`k_edge_augmentation` when k=2, and partial=False. Adding the resulting edges to G will make it 2-edge-connected. If no constraints are specified the returned set of edges is minimum an optimal, otherwise the solution is approximated. Parameters ---------- G : NetworkX graph An undirected graph. avail : dict or a set of 2 or 3 tuples For more details, see :func:`k_edge_augmentation`. weight : string key to use to find weights if ``avail`` is a set of 3-tuples. For more details, see :func:`k_edge_augmentation`. Yields ------ edge : tuple Edges in the bridge-augmentation of G Raises ------ NetworkXUnfeasible If no bridge-augmentation exists. Notes ----- If there are no constraints the solution can be computed in linear time using :func:`unconstrained_bridge_augmentation`. Otherwise, the problem becomes NP-hard and is the solution is approximated by :func:`weighted_bridge_augmentation`. See Also -------- :func:`k_edge_augmentation` z.impossible to bridge connect less than 3 nodes)r0)rr r4!unconstrained_bridge_augmentationweighted_bridge_augmentation)r$r/r0s rr7r7sEX Q##$TUU }033+AVDDr%cX:aX4$X4$)zAReturns the nodes in an undirected edge in lower-triangular orderr)rGrKs r_orderedrusUA6&&r%c&^TcSm[U[5(a3[UR55n[UR 55nOFU4SjnUVs/sHofSSPM nnUVs/sHn[ U5S:XaSO U"US5PM! nnUbhUVVs/sHupxUR Xx5(+PM n nn[[R"X955n[[R"XI55nX44$s snfs snfs snnf)z=Helper to separate avail into edges and corresponding weightsr0c4>UT$![a Us$f=fr) TypeError)rr0s r _try_getitem-_unpack_available_edges.._try_getitems& y   s  rrr ) isinstancedictr9r`valuesr5has_edgeracompress) r/r0r$rerfrytuprGrKflagss ` rrXrXs ~% %u||~&  )..!H.LQRESCA 1<B+@@ER}2:;($!QZZ%%(; H45r{{723  /R>> # Each group represents a meta-node >>> groups = ([1, 2, 3], [4, 5], [6]) >>> mapping = {n: meta_n for meta_n, ns in enumerate(groups) for n in ns} >>> avail_uv = [(1, 2), (3, 6), (1, 4), (5, 2), (6, 1), (2, 6), (3, 1)] >>> avail_w = [20, 99, 20, 15, 50, 99, 20] >>> sorted(_lightest_meta_edges(mapping, avail_uv, avail_w)) [MetaEdge(meta_uv=(0, 1), uv=(5, 2), w=15), MetaEdge(meta_uv=(0, 2), uv=(6, 1), w=50)] N)rr9r[ruappendrBminr) mappingrerf grouped_wuvrSrGrKrmumv choices_wuvs r_lightest_meta_edgesrsBd#K+ 6A7:wz2##Q1I. ,"-!2!2!4+ 8+&GA!B8aVQ/ / "5s A'B-$Bc## [[R"U55n[X5n[UR 55n[[ X3SS55n[ [5nURSR5HupgXWRU5 M UHupXXSXYS4v M g7f)aFinds the smallest set of edges to connect G. This is a variant of the unweighted MST problem. If G is not empty, a feasible solution always exists. Parameters ---------- G : NetworkX graph An undirected graph. Yields ------ edge : tuple Edges in the one-edge-augmentation of G See Also -------- :func:`one_edge_augmentation` :func:`k_edge_augmentation` Examples -------- >>> G = nx.Graph([(1, 2), (2, 3), (4, 5)]) >>> G.add_nodes_from([6, 7, 8]) >>> sorted(unconstrained_one_edge_augmentation(G)) [(1, 4), (4, 6), (6, 7), (7, 8)] r Nrr) r9r connected_componentscollapsergr[rgraphrBr) r$ccs1rh meta_nodesmeta_auginverserrKrrs rrnrnFs: ''* +DAaggiJC qrN34H$G "((* !+{1~w{1~..sB?Cc## [XUS9upE[U[R"U55nURSn[ XtU5nUR SU55 [R"U5n U(d1[R"U 5(d[R"S5eU RSS9Hupn SU ;dMU Sn U v M g7f) a=Finds the minimum weight set of edges to connect G if one exists. This is a variant of the weighted MST problem. Parameters ---------- G : NetworkX graph An undirected graph. avail : dict or a set of 2 or 3 tuples For more details, see :func:`k_edge_augmentation`. weight : string key to use to find weights if ``avail`` is a set of 3-tuples. For more details, see :func:`k_edge_augmentation`. partial : boolean If partial is True and no feasible k-edge-augmentation exists, then the augmenting edges minimize the number of connected components. Yields ------ edge : tuple Edges in the subset of avail chosen to connect G. See Also -------- :func:`one_edge_augmentation` :func:`k_edge_augmentation` Examples -------- >>> G = nx.Graph([(1, 2), (2, 3), (4, 5)]) >>> G.add_nodes_from([6, 7, 8]) >>> # any edge not in avail has an implicit weight of infinity >>> avail = [(1, 3), (1, 5), (4, 7), (4, 8), (6, 1), (8, 1), (8, 2)] >>> sorted(weighted_one_edge_augmentation(G, avail)) [(1, 5), (4, 7), (6, 1), (8, 1)] >>> # find another solution by giving large weights to edges in the >>> # previous solution (note some of the old edges must be used) >>> avail = [(1, 3), (1, 5, 99), (4, 7, 9), (6, 1, 99), (8, 1, 99), (8, 2)] >>> sorted(weighted_one_edge_augmentation(G, avail)) [(1, 5), (4, 7), (6, 1), (8, 2)] rNrc38# UHuupp4XXCS.4v M g7frPr)rrrrrSs rr1weighted_one_edge_augmentation..s%0OHRb A/00sz.Not possible to connect G with available edgesTrVrRN) rXrr rrrrZminimum_spanning_treer!r4r^)r$r/r0r1rerfrhrcandidate_mappingmeta_mstrrrrls rroroqs\0JH B++A./Aggi G,WH0 ''*H 2??844##$TUU^^^.  ! [>DJ/s CC Cc #<^# [[RRT55n[ TU5n[R "U5Vs/sH6n[ U5S:Xa[U5S-O[X2RS9SSPM8 nn[ U5S:aAUVs/sHoUSPM nnUVs/sHoUSPM nn[[USSU55nO/nUR5n U RU5 U R5V V s/sHupU S:XdM U PM n n n [ U 5S:Xa/n [ U 5S:Xa [U 5/n O[SU R555n[R"X5V s/sHoRU 5S:XdMU PM nn [ R""[ U5S- 5n[[USUUU*S55n X-n[%[5nUR&SR)5HunnUUR+U5 M UR)5VVs0sHunnU[UU4SjS9_M nnnTR5nUH_unn[,R."UUUU5H8unnUR1UU5(aMUR3UU5 UU4v M] Ma gs snfs snfs snfs sn n f![a gf=fs sn fs snnf7f) a Finds an optimal 2-edge-augmentation of G using the fewest edges. This is an implementation of the algorithm detailed in [1]_. The basic idea is to construct a meta-graph of bridge-ccs, connect leaf nodes of the trees to connect the entire graph, and finally connect the leafs of the tree in dfs-preorder to bridge connect the entire graph. Parameters ---------- G : NetworkX graph An undirected graph. Yields ------ edge : tuple Edges in the bridge augmentation of G Notes ----- Input: a graph G. First find the bridge components of G and collapse each bridge-cc into a node of a metagraph graph C, which is guaranteed to be a forest of trees. C contains p "leafs" --- nodes with exactly one incident edge. C contains q "isolated nodes" --- nodes with no incident edges. Theorem: If p + q > 1, then at least :math:`ceil(p / 2) + q` edges are needed to bridge connect C. This algorithm achieves this min number. The method first adds enough edges to make G into a tree and then pairs leafs in a simple fashion. Let n be the number of trees in C. Let v(i) be an isolated vertex in the i-th tree if one exists, otherwise it is a pair of distinct leafs nodes in the i-th tree. Alternating edges from these sets (i.e. adding edges A1 = [(v(i)[0], v(i + 1)[1]), v(i + 1)[0], v(i + 2)[1])...]) connects C into a tree T. This tree has p' = p + 2q - 2(n -1) leafs and no isolated vertices. A1 has n - 1 edges. The next step finds ceil(p' / 2) edges to biconnect any tree with p' leafs. Convert T into an arborescence T' by picking an arbitrary root node with degree >= 2 and directing all edges away from the root. Note the implementation implicitly constructs T'. The leafs of T are the nodes with no existing edges in T'. Order the leafs of T' by DFS preorder. Then break this list in half and add the zipped pairs to A2. The set A = A1 + A2 is the minimum augmentation in the metagraph. To convert this to edges in the original graph References ---------- .. [1] Eswaran, Kapali P., and R. Endre Tarjan. (1975) Augmentation problems. http://epubs.siam.org/doi/abs/10.1137/0205044 See Also -------- :func:`bridge_augmentation` :func:`k_edge_augmentation` Examples -------- >>> G = nx.path_graph((1, 2, 3, 4, 5, 6, 7)) >>> sorted(unconstrained_bridge_augmentation(G)) [(1, 7)] >>> G = nx.path_graph((1, 2, 3, 2, 4, 5, 6, 7)) >>> sorted(unconstrained_bridge_augmentation(G)) [(1, 3), (3, 7)] >>> G = nx.Graph([(0, 1), (0, 2), (1, 2)]) >>> G.add_node(4) >>> sorted(unconstrained_bridge_augmentation(G)) [(1, 4), (4, 0)] r r)keyrNc3:# UHupUS:dM Uv M g7fr Nrrrrs rr4unconstrained_bridge_augmentation../s:jdaAEj  rc*>TRU5U4$r)r)rGr$s r3unconstrained_bridge_augmentation..Bs!((1+q)9r%)r9r r(bridge_componentsrrr5tuplesortedrr[rYrZnext StopIterationdfs_preorder_nodesmathceilrrrBrraproductradd_edge)r$ bridge_ccsrhccvset1vsnodes1nodes2A1TrrleafsA2rootv2halfaug_tree_edgesrrrKrmappedG2rrGs` rrrrrsrboo77:;JJA))!,  -B r7a< b A BHH %a * +-     5zA~"'(%BQ%%("'(%BQ%%( #fQRj&) *  AR88: 0:41aQ:E 0 5zQ  5zQEl^ :ahhj::D..q7 L7A88A;!;Ka7 LyyR1% #b$iTEF, -WN$G "((*1 !+ "--/)JB F69 ::)  B BJJwr{GBK8DAq;;q!$$ Aq!d  9!g )( 1   MsA L=K, L"K10L6K6AL K;%K;+0L L<LL0L6B!LL3AL 7L L L LLc ## UcSn[R"U5(d?UR5n[[ X1US95nUR U5 UShvN O/nUn[ U5S:Xa1[R"U5(a[R"S5e[XUS9upV[RRU5n[X75nURSn [XU5V V V V s0sH uuppX4X4_M nn n n n [SUR!555n[R$"X5n[R&"U5R5n[R("USSS 9 [R*"UXR-5S 9nUHduupnXU 4upUU :XaUR/UXU S 9 M)UU :XaUR/UXU S 9 MBUR/UXU S 9 UR/UXU S 9 Mf [1UU5n[55nUR75H4upUR9X5nS U;dMUS nUR;U5 M6 UShvN gGN!s sn n n n f!["a gf=f![R2an[R"S 5UeSnAff=fNS7f)aFinds an approximate min-weight 2-edge-augmentation of G. This is an implementation of the approximation algorithm detailed in [1]_. It chooses a set of edges from avail to add to G that renders it 2-edge-connected if such a subset exists. This is done by finding a minimum spanning arborescence of a specially constructed metagraph. Parameters ---------- G : NetworkX graph An undirected graph. avail : set of 2 or 3 tuples. candidate edges (with optional weights) to choose from weight : string key to use to find weights if avail is a set of 3-tuples where the third item in each tuple is a dictionary. Yields ------ edge : tuple Edges in the subset of avail chosen to bridge augment G. Notes ----- Finding a weighted 2-edge-augmentation is NP-hard. Any edge not in ``avail`` is considered to have a weight of infinity. The approximation factor is 2 if ``G`` is connected and 3 if it is not. Runs in :math:`O(m + n log(n))` time References ---------- .. [1] Khuller, Samir, and Ramakrishna Thurimella. (1993) Approximation algorithms for graph augmentation. http://www.sciencedirect.com/science/article/pii/S0196677483710102 See Also -------- :func:`bridge_augmentation` :func:`k_edge_augmentation` Examples -------- >>> G = nx.path_graph((1, 2, 3, 4)) >>> # When the weights are equal, (1, 4) is the best >>> avail = [(1, 4, 1), (1, 3, 1), (2, 4, 1)] >>> sorted(weighted_bridge_augmentation(G, avail)) [(1, 4)] >>> # Giving (1, 4) a high weight makes the two edge solution the best. >>> avail = [(1, 4, 1000), (1, 3, 1), (2, 4, 1)] >>> sorted(weighted_bridge_augmentation(G, avail)) [(1, 3), (2, 4)] >>> # ------ >>> G = nx.path_graph((1, 2, 3, 4)) >>> G.add_node(5) >>> avail = [(1, 5, 11), (2, 5, 10), (4, 3, 1), (4, 5, 1)] >>> sorted(weighted_bridge_augmentation(G, avail=avail)) [(1, 5), (4, 5)] >>> avail = [(1, 5, 11), (2, 5, 10), (4, 3, 1), (4, 5, 51)] >>> sorted(weighted_bridge_augmentation(G, avail=avail)) [(1, 5), (2, 5), (4, 5)] Nr0r2rzno augmentation possiblerNrc3:# UHupUS:XdM Uv M g7frrrs rr/weighted_bridge_augmentation..s7*$!QAA*rnamer~)rpairsrQzno 2-edge-augmentation possiblerR)r r!rYr9r6rZr5r"r4rXr(rrrrrrrdfs_treereverseset_edge_attributes%tree_all_pairs_lowest_common_ancestorr`r_minimum_rooted_branchingNetworkXExceptionr@r^rcadd)r$r/r0rD connectorsrerfrrhrrrrrS meta_to_wuvrTRDlca_genlcaAerrbridge_connectorsrWrls rrsrsQsD~ ??1   FFH/vNO  $  5zQ >>!  ''(BC C/JH2215JAggi G 4GwOOOHRb 1'O$7!((*77 Q B 2A18A666 --/G! #H% "9 JJsBBJ 7 BY JJsBBJ 7 JJsBBJ 7 JJsBBJ 7! P &a .'')r& $  $D  ! !$ ' !  { $( L   P##$EFCOP"!sAK I=BK <J K  J6CK  J 4K K 7K 8K K  JK JK K,KKK cUR5nURURU5Vs/sHo3U4PM sn5 [R"U5nU$s snf)a:Helper function to compute a minimum rooted branching (aka rooted arborescence) Before the branching can be computed, the directed graph must be rooted by removing the predecessors of root. A branching / arborescence of rooted graph G is a subgraph that contains a directed path from the root to every other vertex. It is the directed analog of the minimum spanning tree problem. References ---------- [1] Khuller, Samir (2002) Advanced Algorithms Lecture 24 Notes. https://web.archive.org/web/20121030033722/https://www.cs.umd.edu/class/spring2011/cmsc651/lec07.pdf )rYr_ predecessorsr minimum_spanning_arborescence)rrrootedrGrs rrrsT VVXF 1EF1EA$i1EFG ((0A HGs AT) returns_graphc^^ 0m 0nUR5nSm[UR55n[U5H^umn[U5nUR U5(dS5eUR U5 XRT'T R U4SjU55 M` [UTS-S9H(umnU1nXRT'T R U4SjU55 M* TS-nUR[U55 URU 4SjUR555 [R"USUS 9 T URS 'U$) aCollapses each group of nodes into a single node. This is similar to condensation, but works on undirected graphs. Parameters ---------- G : NetworkX Graph grouped_nodes: list or generator Grouping of nodes to collapse. The grouping must be disjoint. If grouped_nodes are strongly_connected_components then this is equivalent to :func:`condensation`. Returns ------- C : NetworkX Graph The collapsed graph C of G with respect to the node grouping. The node labels are integers corresponding to the index of the component in the list of grouped_nodes. C has a graph attribute named 'mapping' with a dictionary mapping the original nodes to the nodes in C to which they belong. Each node in C also has a node attribute 'members' with the set of original nodes in G that form the group that the node in C represents. Examples -------- >>> # Collapses a graph using disjoint groups, but not necessarily connected >>> G = nx.Graph([(1, 0), (2, 3), (3, 1), (3, 4), (4, 5), (5, 6), (5, 7)]) >>> G.add_node("A") >>> grouped_nodes = [{0, 1, 2, 3}, {5, 6, 7}] >>> C = collapse(G, grouped_nodes) >>> members = nx.get_node_attributes(C, "members") >>> sorted(members.keys()) [0, 1, 2, 3] >>> member_values = set(map(frozenset, members.values())) >>> assert {0, 1, 2, 3} in member_values >>> assert {4} in member_values >>> assert {5, 6, 7} in member_values >>> assert {"A"} in member_values rz-grouped nodes must exist in G and be disjointc3*># UHoT4v M g7frrrris rrcollapse..J-u!1vur )startc3*># UHoT4v M g7frrrs rrrOrrc3X># UHupTUTU:wdMTUTU4v M! g7frr)rrGrKrs rrrRs6-6TQ'!*PQ :R WQZ Ys**membersrr) __class__r@rg enumerate issupersetdifference_updateupdateadd_nodes_fromrangerZr^r set_node_attributesr) r$ grouped_nodesrrh remaininggroupnodenumber_of_groupsrrs @@rrrs?TGG A AAGGIIm,5E ##    ; : ;  ##E* -u---Ya!e44 -u--51uU+,--.WWY19W= AGGI Hr%c#^# URnUR5(aK[R"UR 5S5H!up#X1U;aX#4v X!U;dMX24v M# g[R"UR 5S5Hup#X1U;dMX#4v M g7f)aReturns only the edges in the complement of G Parameters ---------- G : NetworkX Graph Yields ------ edge : tuple Edges in the complement of G Examples -------- >>> G = nx.path_graph((1, 2, 3, 4)) >>> sorted(complement_edges(G)) [(1, 3), (1, 4), (2, 4)] >>> G = nx.path_graph((1, 2, 3, 4), nx.DiGraph()) >>> sorted(complement_edges(G)) [(1, 3), (1, 4), (2, 1), (2, 4), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3)] >>> G = nx.complete_graph(1000) >>> sorted(complement_edges(G)) [] rN)_adj is_directedrarbrg)r$G_adjrGrKs rr:r:\s2 FFE}}OOAGGIq1DAa f a f 2 OOAGGIq1DAa f 2sAB-%:B-# B-c&URU5 g)z=wrapper around rng.shuffle for python 2 compatibility reasonsN)shuffle)rnginputs r_compat_shufflersKKr%c #,# /n[X5nU(agUc$[[U55nS/[U5-nO [ X#US9upxUV s/sH"n [ [ URU 55PM$ n n [[XU55n U V V V s/sHupoPM nn n n UR5nUH{unnSn[XUUS9(dZURUU45 URUU5 URU5U:a URU5U:a [X5nU(dM{ O U(d[R"S5e[!XE5 [U5HunnURU5U::dURU5U::aM2UR#UU5 UR%UU45 [XS9(aMgURUU5 URUU45 M UShvN gs sn fs sn n n fN7f)aGreedy algorithm for finding a k-edge-augmentation Parameters ---------- G : NetworkX graph An undirected graph. k : integer Desired edge connectivity avail : dict or a set of 2 or 3 tuples For more details, see :func:`k_edge_augmentation`. weight : string key to use to find weights if ``avail`` is a set of 3-tuples. For more details, see :func:`k_edge_augmentation`. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Yields ------ edge : tuple Edges in the greedy augmentation of G Notes ----- The algorithm is simple. Edges are incrementally added between parts of the graph that are not yet locally k-edge-connected. Then edges are from the augmenting set are pruned as long as local-edge-connectivity is not broken. This algorithm is greedy and does not provide optimality guarantees. It exists only to provide :func:`k_edge_augmentation` with the ability to generate a feasible solution for arbitrary k. See Also -------- :func:`k_edge_augmentation` Examples -------- >>> G = nx.path_graph((1, 2, 3, 4, 5, 6, 7)) >>> sorted(greedy_k_edge_augmentation(G, k=2)) [(1, 7)] >>> sorted(greedy_k_edge_augmentation(G, k=1, avail=[])) [] >>> G = nx.path_graph((1, 2, 3, 4, 5, 6, 7)) >>> avail = {(u, v): 1 for (u, v) in complement_edges(G)} >>> # randomized pruning process can produce different solutions >>> sorted(greedy_k_edge_augmentation(G, k=4, avail=avail, seed=2)) [(1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 4), (2, 6), (3, 7), (5, 7)] >>> sorted(greedy_k_edge_augmentation(G, k=4, avail=avail, seed=3)) [(1, 3), (1, 5), (1, 6), (2, 4), (2, 6), (3, 7), (4, 7), (5, 7)] Nr rNFrUz/not able to k-edge-connect with available edges)rr9r:r5rXsummaprrr[rYr rrr r4r remove_edgeremove)r$rr/r0r3r=donererfr tiebreaker avail_wduvrSrrDrGrKs rr8r8szI q $D  }(+,#H %4EAN4<<8R#c!((B'(8J<G:;J#-.:xqR:H. A1*1a8   aV $ JJq! xx{aAHHQK1$4*10 4  ##$UVVD$Y1 88A;! qxx{a/  a!Q "1** JJq!    aV $ I=.Ds8A H)H8HH #B H4BH.HHH)NNFr)NN)NF)NNN)!__doc__ itertoolsrar collectionsrrnetworkxr networkx.utilsrr__all__ _dispatchablerr rr;r6r7rurXrrrnrorrrsrrr:rr8rr%rr se  /? WZ \"-:#!-:`Z \"4#!4nZ \"S#!SlaaH\"Z 1 !#1 h\"Z .E!#.Eh' 4 j"8 9.0b'/'/TAAHWWtg!g!T 0%D &D N""J \"Z k!#kr%