+ j"zRt^RIt^RIHtR.tRtRt]P!R] !R4/RRR 7R R l4t R#) z3 Edmonds-Karp algorithm for maximum flow problems. N)build_residual_network edmonds_karpcaaa aaVPpVPo VPoVPR,oVV3RlpV VVV3Rlp^pWs8d}V!4wrp V fV#V.p Tp V S8wdW,p V P V 4K"V P 4Tp V S8wdW,p V P V 4K"Wu!V 4, pKV#)-Implementation of the Edmonds-Karp algorithm.infc<Sp\V4p\V4pVF5pSV,V,p\WR,VR,, 4pTpK7 V^,S8d\P!R4h\V4p\V4pVFKpSV,V,R;;,V, uu&SV,V,R;;,V,uu&TpKM V#)z&Augment flow along a path from s to t.capacityflowz-Infinite capacity path, flow unbounded above.)iternextminnxNetworkXUnbounded)pathr ituvattrR_succrs& e/home/luca/screen-checking/.venv/lib/python3.14/site-packages/networkx/algorithms/flow/edmondskarp.pyaugment"edmonds_karp_core..augments $Z HA!9Q&&'VW W $Z HA 1IaL D ( 1IaL D ( A c><S R/pS .pS R/pS .p.p\V4\V48:dzVFepS V,P4FGwrgW`9gK VR,VR,8gK$WPV&Wb9d W`V3uu#VPV4KI Kg V'gR#TpKVFepSV,P4FGwrgWb9gK VR,VR,8gK$WRV&W`9d W`V3uu#VPV4KI Kg V'gR#TpEK)z:Bidirectional breadth-first search for an augmenting path.Nr r)NNN)lenitemsappend) predq_ssuccq_tqrrrR_predrsts rbidirectional_bfs,edmonds_karp_core..bidirectional_bfs(s 4yc4ycA3x3s8#A#)!9??#4=T&\DAGGL HrrrT) edge_attrs returns_graphpreserve_edge_attrscj\WW#WF4pRVPR&\P!V4V#)aFind a maximum single-commodity flow using the Edmonds-Karp algorithm. This function returns the residual network resulting after computing the maximum flow. See below for details about the conventions NetworkX uses for defining residual networks. This algorithm has a running time of $O(n m^2)$ for $n$ nodes and $m$ edges. Parameters ---------- G : NetworkX graph Edges of the graph are expected to have an attribute called 'capacity'. If this attribute is not present, the edge is considered to have infinite capacity. s : node Source node for the flow. t : node Sink node for the flow. capacity : string or function (default= 'capacity') If this is a string, then edge capacity will be accessed via the edge attribute with this key (that is, the capacity of the edge joining `u` to `v` will be ``G.edges[u, v][capacity]``). If no such edge attribute exists, the capacity of the edge is assumed to be infinite. If this is a function, the capacity 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 or None to indicate a hidden edge. residual : NetworkX graph Residual network on which the algorithm is to be executed. If None, a new residual network is created. Default value: None. value_only : bool If True compute only the value of the maximum flow. This parameter will be ignored by this algorithm because it is not applicable. cutoff : integer, float If specified, the algorithm will terminate when the flow value reaches or exceeds the cutoff. In this case, it may be unable to immediately determine a minimum cut. Default value: None. Returns ------- R : NetworkX DiGraph Residual network after computing the maximum flow. Raises ------ NetworkXError The algorithm does not support MultiGraph and MultiDiGraph. If the input graph is an instance of one of these two classes, a NetworkXError is raised. NetworkXUnbounded If the graph has a path of infinite capacity, the value of a feasible flow on the graph is unbounded above and the function raises a NetworkXUnbounded. See also -------- :meth:`maximum_flow` :meth:`minimum_cut` :meth:`preflow_push` :meth:`shortest_augmenting_path` Notes ----- The residual network :samp:`R` from an input graph :samp:`G` has the same nodes as :samp:`G`. :samp:`R` is a DiGraph that contains a pair of edges :samp:`(u, v)` and :samp:`(v, u)` iff :samp:`(u, v)` is not a self-loop, and at least one of :samp:`(u, v)` and :samp:`(v, u)` exists in :samp:`G`. For each edge :samp:`(u, v)` in :samp:`R`, :samp:`R[u][v]['capacity']` is equal to the capacity of :samp:`(u, v)` in :samp:`G` if it exists in :samp:`G` or zero otherwise. If the capacity is infinite, :samp:`R[u][v]['capacity']` will have a high arbitrary finite value that does not affect the solution of the problem. This value is stored in :samp:`R.graph['inf']`. For each edge :samp:`(u, v)` in :samp:`R`, :samp:`R[u][v]['flow']` represents the flow function of :samp:`(u, v)` and satisfies :samp:`R[u][v]['flow'] == -R[v][u]['flow']`. The flow value, defined as the total flow into :samp:`t`, the sink, is stored in :samp:`R.graph['flow_value']`. If :samp:`cutoff` is not specified, reachability to :samp:`t` using only edges :samp:`(u, v)` such that :samp:`R[u][v]['flow'] < R[u][v]['capacity']` induces a minimum :samp:`s`-:samp:`t` cut. Examples -------- >>> from networkx.algorithms.flow import edmonds_karp The functions that implement flow algorithms and output a residual network, such as this one, are not imported to the base NetworkX namespace, so you have to explicitly import them from the flow package. >>> G = nx.DiGraph() >>> G.add_edge("x", "a", capacity=3.0) >>> G.add_edge("x", "b", capacity=1.0) >>> G.add_edge("a", "c", capacity=3.0) >>> G.add_edge("b", "c", capacity=5.0) >>> G.add_edge("b", "d", capacity=4.0) >>> G.add_edge("d", "e", capacity=2.0) >>> G.add_edge("c", "y", capacity=2.0) >>> G.add_edge("e", "y", capacity=3.0) >>> R = edmonds_karp(G, "x", "y") >>> flow_value = nx.maximum_flow_value(G, "x", "y") >>> flow_value 3.0 >>> flow_value == R.graph["flow_value"] True r algorithm)r9r(r _clear_cache)r5r#r$rr6 value_onlyr+r*s&&&&&&& rrr}s2~ !X>A)AGGKOOA Hr)rNFN) __doc__networkxr networkx.algorithms.flow.utilsr__all__r.r9 _dispatchabler4rrrrGsXA  Pf >E%L)SW  r