U 9%e@sdZddlZddlmZmZddlmZddlmZddl m Z ddl Z ddl mZdd lmZmZd d d d ddddgZddhZddddZedZedd4ddZddZddZd5d d Zed!d6d"d ZGd#d$d$e jZd%d&ZGd'ddZd7d)d Z d8d*d Z!d9d+dZ"d:d,dZ#d-Z$e$d.Z%e$j&d/dd0e _e$j&d1dd0e!_e%j&d/d2d0e"_e%j&d1d2d0e#_Gd3ddZ'dS);u Algorithms for finding optimum branchings and spanning arborescences. This implementation is based on: J. Edmonds, Optimum branchings, J. Res. Natl. Bur. Standards 71B (1967), 233–240. URL: http://archive.org/details/jresv71Bn4p233 N) dataclassfield)Enum) itemgetter) PriorityQueue)py_random_state)is_arborescence is_branchingbranching_weightgreedy_branchingmaximum_branchingminimum_branchingmaximum_spanning_arborescenceminimum_spanning_arborescenceArborescenceIteratorEdmondsmaxmin branching arborescence)rrspanning arborescenceinfcsdfddt|DS)Ncsg|]}tjqS)choicestring ascii_letters).0nseedrb/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/networkx/algorithms/tree/branchings.py @sz!random_string..)joinrange)Lr"rr!r# random_string>sr(cCs| SNrweightrrr# _min_weightCsr,cCs|Sr)rr*rrr# _max_weightGsr-r+cs tfdd|jddDS)a Returns the total weight of a branching. You must access this function through the networkx.algorithms.tree module. Parameters ---------- G : DiGraph The directed graph. attr : str The attribute to use as weights. If None, then each edge will be treated equally with a weight of 1. default : float When `attr` is not None, then if an edge does not have that attribute, `default` specifies what value it should take. Returns ------- weight: int or float The total weight of the branching. Examples -------- >>> G = nx.DiGraph() >>> G.add_weighted_edges_from([(0, 1, 2), (1, 2, 4), (2, 3, 3), (3, 4, 2)]) >>> nx.tree.branching_weight(G) 11 c3s|]}|dVqdS)Nget)redgeattrdefaultrr# isz#branching_weight..Tdata)sumedges)Gr3r4rr2r#r Kscs$|tkrtd|dkr d}nd}dkr6t|dfdd|jdd D}z|jtd d d |d Wn&tk r|jtd |d YnXt}| |tj }t |D]f\} \} } } || || krqq| | d krqqi} dk r| | <|j| | f| || | q|S)a7 Returns a branching obtained through a greedy algorithm. This algorithm is wrong, and cannot give a proper optimal branching. However, we include it for pedagogical reasons, as it can be helpful to see what its outputs are. The output is a branching, and possibly, a spanning arborescence. However, it is not guaranteed to be optimal in either case. Parameters ---------- G : DiGraph The directed graph to scan. attr : str The attribute to use as weights. If None, then each edge will be treated equally with a weight of 1. default : float When `attr` is not None, then if an edge does not have that attribute, `default` specifies what value it should take. kind : str The type of optimum to search for: 'min' or 'max' greedy branching. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Returns ------- B : directed graph The greedily obtained branching. Unknown value for `kind`.rFTNr!cs$g|]\}}}|||fqSrr/)ruvr7r2rr#r$sz$greedy_branching..r6r.rr)keyreverse)KINDSnxNetworkXExceptionr(r9sortr TypeErrorZDiGraphadd_nodes_fromutils UnionFind enumerate in_degreeadd_edgeunion)r:r3r4kindr"r@r9Bufir=r>wr7rr2r#r ls4"     csReZdZdZdfdd ZddZddZd d Zd d Zd dZ ddZ Z S)MultiDiGraph_EdgeKeya MultiDiGraph which assigns unique keys to every edge. Adds a dictionary edge_index which maps edge keys to (u, v, data) tuples. This is not a complete implementation. For Edmonds algorithm, we only use add_node and add_edge, so that is all that is implemented here. During additions, any specified keys are ignored---this means that you also cannot update edge attributes through add_node and add_edge. Why do we need this? Edmonds algorithm requires that we track edges, even as we change the head and tail of an edge, and even changing the weight of edges. We must reliably track edges across graph mutations. Nc s*t}|jfd|i|||_i|_dS)Nincoming_graph_data)super__init___cls edge_index)selfrSr3cls __class__rr#rUszMultiDiGraph_EdgeKey.__init__cCsdt}|j|D]}||q|j|D]}||q2|D] }|j|=qF|j|dSr))setpredvaluesupdatesuccrWrV remove_node)rXr keysZkeydictr?rrr#ras   z MultiDiGraph_EdgeKey.remove_nodecCs|D]}||qdSr))ra)rXnbunchr rrr#remove_nodes_fromsz&MultiDiGraph_EdgeKey.remove_nodes_fromc Ks|||}}}||jkrJ|j|\}} } ||ks:|| krJtd|d|jj|||f||||j|||f|j|<dS)z' Key is now required. zKey z is already in use.N)rW ExceptionrVrKr`) rXZ u_for_edgeZ v_for_edgeZ key_for_edger3r=r>r?uuvv_rrr#rKs zMultiDiGraph_EdgeKey.add_edgecKs(|D]\}}}}|j|||f|qdSr))rK)rXZ ebunch_to_addr3r=r>kdrrr#add_edges_fromsz#MultiDiGraph_EdgeKey.add_edges_fromc Csdz|j|\}}}Wn2tk rF}ztd||W5d}~XYnX|j|=|j|||dS)NzInvalid edge key )rWKeyErrorrVZ remove_edge)rXr?r=r>rherrrrr#remove_edge_with_keys "z)MultiDiGraph_EdgeKey.remove_edge_with_keycCstdSr))NotImplementedError)rXZebunchrrr#remove_edges_fromsz&MultiDiGraph_EdgeKey.remove_edges_from)N) __name__ __module__ __qualname____doc__rUrardrKrkrnrp __classcell__rrrZr#rRs  rRcsBt||fddfddtddD}|fS)z Returns the edge keys of the unique path between u and v. This is not a generic function. G must be a branching and an instance of MultiDiGraph_EdgeKey. cs$||}t|}|dS)Nr)rblist)rPrgrb)r:nodesrr# first_keyszget_path..first_keycsg|]\}}||qSrr)rrPrg)rxrr#r$szget_path..rN)rBZ shortest_pathrI)r:r=r>r9r)r:rxrwr#get_pathsryc@s,eZdZdZdddZddZdd d ZdS)ra Edmonds algorithm [1]_ for finding optimal branchings and spanning arborescences. This algorithm can find both minimum and maximum spanning arborescences and branchings. Notes ----- While this algorithm can find a minimum branching, since it isn't required to be spanning, the minimum branching is always from the set of negative weight edges which is most likely the empty set for most graphs. References ---------- .. [1] J. Edmonds, Optimum Branchings, Journal of Research of the National Bureau of Standards, 1967, Vol. 71B, p.233-240, https://archive.org/details/jresv71Bn4p233 NcCs&||_d|_g|_t|dd|_dS)NTr!z_{0}) G_originalstorer9r(template)rXr:r"rrr#rU1szEdmonds.__init__cCsD|tkrtd||_||_||_||_|dkr>t|_}n t |_}|dkrZt |d}||_ dt |d|_ t |_} t|jjddD]v\} \} } } ||| ||i}| |dk r| |||<|r| D]\}}||kr|||<q| j| | | f|qd|_t |_i|j_g|_g|_tj|_g|_g|_dS)Nr<rr!Z candidate_Tr6r)rArBrCr3r4rMstyler,transr-r(_attrcandidate_attrrRr:rIrzr9r0itemsrKlevelrNrWgraphs branchingsrGrHrOcircuitsminedge_circuit)rXr3r4rMr}preserve_attrsr" partitionr~r:r?r=r>r7rjZd_kZd_vrrr#_init>s>         z Edmonds._initr+rrrFc) s|||||||j}|j|j} t} tt} |jj } fdd} z t | }Wnt k rt t | kst t | rt| st |jr|j|j| |jg|jdYqYn X|| krq\| || || |\}}|dkr"q\q\|d}||||kr\t| ||\}}||dnd\}}|jdkr|dkrd}nd }|r\|i}|d dk r|d |<| j|||df|d |||d|j<||||dk r\t}d}i}|D]P}| j|\}}}|}|||<|t j!j"krFq ||kr |}|}q |j||j||jr|j|j| |j#$|j%}|g}j&d d d D]\}}}}||kr||krqn|}|||||fnJ||kr|}||||7}|}||<|||||fnqƐqƈ'|| '|| (t||D]R\}}}}j|||f||j|kr|||j=| j|||f||||q|tt} |j%d 7_%q\|j)*}d d} t|j|j%j}!|j%dkr|j%d 8_%|j#$|j%}"|j|j%}#| |j|j%d |"|!\}$}%|!+|#|$r|j|j%}|dkrt,|!-|nX|j|j%j|%d }&|#D]&}%j|%\}}}||&krqqt,d|!-|%q|!|_&|.|j)|!D]v}%|jdj|%\}}}'|j/|0|'|j/i}|rp|'1D]$\}}(||j/|jfkrJ|(||<qJ|j||f|q |S)a9 Returns a branching from G. Parameters ---------- attr : str The edge attribute used to in determining optimality. default : float The value of the edge attribute used if an edge does not have the attribute `attr`. kind : {'min', 'max'} The type of optimum to search for, either 'min' or 'max'. style : {'branching', 'arborescence'} If 'branching', then an optimal branching is found. If `style` is 'arborescence', then a branching is found, such that if the branching is also an arborescence, then the branching is an optimal spanning arborescences. A given graph G need not have an optimal spanning arborescence. preserve_attrs : bool If True, preserve the other edge attributes of the original graph (that are not the one passed to `attr`) partition : str The edge attribute holding edge partition data. Used in the spanning arborescence iterator. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Returns ------- H : (multi)digraph The branching. csd}t }j|dddD]r\}}}}|tjjkr:q|}|tjjkrr|}|||||f}||fS||kr|}|||||f}q||fS)aQ Find the edge directed toward v with maximal weight. If an edge partition exists in this graph, return the included edge if it exists and no not return any excluded edges. There can only be one included edge for each vertex otherwise the edge partition is empty. NTr7rb)INFin_edgesr0rB EdgePartitionEXCLUDEDINCLUDED)r>r1r+r=rhr?r7Z new_weightr:r3rrr# desired_edges  z*Edmonds.find_optimum..desired_edgeNrr.)NNrFTr;rrcSsV||krt|d|j|D]0}|j||D]}||kr2d|fSq2q dS)z Returns True if `u` is a root node in G. Node `u` will be a root node if its in-degree, restricted to the specified edges, is equal to 0. z not in GF)TNN)rer])r:r=Zedgekeysr>edgekeyrrr#is_rootlsz%Edmonds.find_optimum..is_rootz+Couldn't find edge incoming to merged node.)2rrOr:rNr\iterrvrwrr]next StopIterationlenAssertionErrorr r{rappendcopyrrraddadd_noderyr}r0rKrrLrrWrBrrr|formatrr9rddifference_updaterzr[r_reremoverFr3r~r))rXr3r4rMr}rrr"rOrNDrwZG_predrr>r1r+r=ZQ_nodesZQ_edgesZ acceptableddZ minweightZminedgeZQ_incoming_weightZedge_keyr7rQnew_nodeZ new_edgesr?Hrr9Z merged_nodeZcircuitZisrootrtargetrjvaluerrr# find_optimums,                                zEdmonds.find_optimum)N)r+rrrFNN)rqrrrsrtrUrrrrrr#rs GFcCs"t|}|j||dd||d}|S)NrrrMr}rrrrr:r3r4rredrNrrr#r scCs"t|}|j||dd||d}|S)Nrrrrrrrr#rscCs:t|}|j||dd||d}t|s6d}tj||S)Nrrrz&No maximum spanning arborescence in G.rrr rB exceptionrCr:r3r4rrrrNmsgrrr#rs cCs:t|}|j||dd||d}t|s6d}tj||S)Nrrrz&No minimum spanning arborescence in G.rrrrr#rs a Returns a {kind} {style} from G. Parameters ---------- G : (multi)digraph-like The graph to be searched. attr : str The edge attribute used to in determining optimality. default : float The value of the edge attribute used if an edge does not have the attribute `attr`. preserve_attrs : bool If True, preserve the other attributes of the original graph (that are not passed to `attr`) partition : str The key for the edge attribute containing the partition data on the graph. Edges can be included, excluded or open using the `EdgePartition` enum. Returns ------- B : (multi)digraph-like A {kind} {style}. zV Raises ------ NetworkXException If the graph does not contain a {kind} {style}. maximum)rMr}minimumrc@sZeZdZdZeddGdddZddd Zd d Zd d ZddZ ddZ ddZ dS)ru Iterate over all spanning arborescences of a graph in either increasing or decreasing cost. Notes ----- This iterator uses the partition scheme from [1]_ (included edges, excluded edges and open edges). It generates minimum spanning arborescences using a modified Edmonds' Algorithm which respects the partition of edges. For arborescences with the same weight, ties are broken arbitrarily. References ---------- .. [1] G.K. Janssens, K. Sörensen, An algorithm to generate all spanning trees in order of increasing cost, Pesquisa Operacional, 2005-08, Vol. 25 (2), p. 219-229, https://www.scielo.br/j/pope/a/XHswBwRwJyrfL88dmMwYNWp/?lang=en T)orderc@s4eZdZUdZeed<eddZeed<ddZ dS) zArborescenceIterator.Partitionz This dataclass represents a partition and stores a dict with the edge data and the weight of the minimum spanning arborescence of the partition dict. mst_weightF)comparepartition_dictcCst|j|jSr))r Partitionrrr)rXrrr#__copy___sz'ArborescenceIterator.Partition.__copy__N) rqrrrsrtfloat__annotations__rrdictrrrrr#rTs rr+NcCs||_||_||_|rtnt|_d|_|dk rzi}|dD]}tj j ||<q>|dD]}tj j ||<qXt d||_nd|_dS)a Initialize the iterator Parameters ---------- G : nx.DiGraph The directed graph which we need to iterate trees over weight : String, default = "weight" The edge attribute used to store the weight of the edge minimum : bool, default = True Return the trees in increasing order while true and decreasing order while false. init_partition : tuple, default = None In the case that certain edges have to be included or excluded from the arborescences, `init_partition` should be in the form `(included_edges, excluded_edges)` where each edges is a `(u, v)`-tuple inside an iterable such as a list or set. z;ArborescenceIterators super secret partition attribute nameNrr)rr:r+rrrmethod partition_keyrBrrrrrinit_partition)rXr:r+rrrerrr#rUds    zArborescenceIterator.__init__cCst|_||j|jdk r*||j|j|j|j|jddj |jd}|j | |j r`|n| |jdkrrin|jj |S)zu Returns ------- ArborescenceIterator The iterator object for this graph NTrrr*)rpartition_queue_clear_partitionr:r_write_partitionrr+rsizeputrrr)rXrrrr#__iter__s*    zArborescenceIterator.__iter__cCs\|jr|`|`t|j}|||j|j|j|jdd}| ||| ||S)z Returns ------- (multi)Graph The spanning tree of next greatest weight, which ties broken arbitrarily. Tr) remptyr:rr0rrr+r _partitionr)rXrZnext_arborescencerrr#__next__s     zArborescenceIterator.__next__c Cs|d|j}|d|j}|jD]}||jkr*tjj|j|<tjj|j|<||zL|j |j |j |j dd}|j |j d}|jr|n| |_|j|Wntjk rYnX|j|_q*dS)a Create new partitions based of the minimum spanning tree of the current minimum partition. Parameters ---------- partition : Partition The Partition instance used to generate the current minimum spanning tree. partition_arborescence : nx.Graph The minimum spanning arborescence of the input partition. rTrr*N)rrrr9rBrrrrrr:r+rrrrrrrrC)rXrZpartition_arborescencep1p2rZp1_mstZ p1_mst_weightrrr#rs(   zArborescenceIterator._partitioncCs|jjddD]<\}}}||f|jkr<|j||f||j<qtjj||j<q|jD]}d}d}|jj|ddD]D\}}}||jtjj kr|d7}qn||jtjj krn|d7}qn|dkrR||j |dkrR|jj|ddD],\}}}||jtjj krtjj ||j<qqRdS)a Writes the desired partition into the graph to calculate the minimum spanning tree. Also, if one incoming edge is included, mark all others as excluded so that if that vertex is merged during Edmonds' algorithm we cannot still pick another of that vertex's included edges. Parameters ---------- partition : Partition A Partition dataclass describing a partition on the edges of the graph. Tr6r)rcr7rN) r:r9rrrBrZOPENrr0rrrJ)rXrr=r>rjr Zincluded_countZexcluded_countrrr#rs    z%ArborescenceIterator._write_partitioncCs.|jddD]\}}}|j|kr ||j=q dS)z7 Removes partition data from the graph Tr6N)r9r)rXr:r=r>rjrrr#rs z%ArborescenceIterator._clear_partition)r+TN) rqrrrsrtrrrUrrrrrrrrr#r?s + (")rN)r+r)r+rrN)r+rFN)r+rFN)r+rFN)r+rFN)(rtr dataclassesrrenumroperatorrqueuerZnetworkxrBZnetworkx.utilsrZ recognitionr r __all__rAZSTYLESrrr(r,r-r r Z MultiDiGraphrRryrr rrrZdocstring_branchingZdocstring_arborescencerrrrrr#s       ! OG0