h\SrSSKrSSKrSSKJr SSKJrJrJ r /SQr Sr Sr \"S5\R"S S 9SS j55rS r\R"S S 9SSj5r\"S5\ "S5\R"S S S9SSj555r\R"S S S S9SSj5r\RS5r\R"S S 9SSj5r\ "S5\R"S S 9SSj55r\ "S5\R"S S 9SSj55rg) a ================================= Travelling Salesman Problem (TSP) ================================= Implementation of approximate algorithms for solving and approximating the TSP problem. Categories of algorithms which are implemented: - Christofides (provides a 3/2-approximation of TSP) - Greedy - Simulated Annealing (SA) - Threshold Accepting (TA) - Asadpour Asymmetric Traveling Salesman Algorithm The Travelling Salesman Problem tries to find, given the weight (distance) between all points where a salesman has to visit, the route so that: - The total distance (cost) which the salesman travels is minimized. - The salesman returns to the starting point. - Note that for a complete graph, the salesman visits each point once. The function `travelling_salesman_problem` allows for incomplete graphs by finding all-pairs shortest paths, effectively converting the problem to a complete graph problem. It calls one of the approximate methods on that problem and then converts the result back to the original graph using the previously found shortest paths. TSP is an NP-hard problem in combinatorial optimization, important in operations research and theoretical computer science. http://en.wikipedia.org/wiki/Travelling_salesman_problem N)random_spanning_tree)not_implemented_forpairwisepy_random_state)traveling_salesman_problem christofides asadpour_atsp greedy_tspsimulated_annealing_tspthreshold_accepting_tspcpUR[S[U5S- 5SS9up#XXsX'X'U$)aSwap two nodes in `soln` to give a neighbor solution. Parameters ---------- soln : list of nodes Current cycle of nodes seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Returns ------- list The solution after move is applied. (A neighbor solution.) Notes ----- This function assumes that the incoming list `soln` is a cycle (that the first and last element are the same) and also that we don't want any move to change the first node in the list (and thus not the last node either). The input list is changed as well as returned. Make a copy if needed. See Also -------- move_one_node k)samplerangelensolnseedabs f/var/www/html/env/lib/python3.13/site-packages/networkx/algorithms/approximation/traveling_salesman.pyswap_two_nodesr5s@< ;;uQD A .!; 4DAwDGTW KcUR[S[U5S- 5SS9up#URX0R U55 U$)amMove one node to another position to give a neighbor solution. The node to move and the position to move to are chosen randomly. The first and last nodes are left untouched as soln must be a cycle starting at that node. Parameters ---------- soln : list of nodes Current cycle of nodes seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Returns ------- list The solution after move is applied. (A neighbor solution.) Notes ----- This function assumes that the incoming list `soln` is a cycle (that the first and last element are the same) and also that we don't want any move to change the first node in the list (and thus not the last node either). The input list is changed as well as returned. Make a copy if needed. See Also -------- swap_two_nodes rrr)rrrinsertpoprs r move_one_noder XsAD ;;uQD A .!; 4DAKK88A; Krdirectedweight) edge_attrscB^ [R"U5n[U5nUR5nUR XD5 UR SU55 [U5S- m [U 4SjURR555(a[R"S5eUc[R"XS9nUR5nURURVVs/sHupgUS-(aMUPM snn5 [R"5nUR!UR"5 [R$"XQS9n UR!U 5 ['[R("U55$![ a GN:f=fs snnf)a Approximate a solution of the traveling salesman problem Compute a 3/2-approximation of the traveling salesman problem in a complete undirected graph using Christofides [1]_ algorithm. Parameters ---------- G : Graph `G` should be a complete weighted undirected graph. The distance between all pairs of nodes should be included. weight : string, optional (default="weight") Edge data key corresponding to the edge weight. If any edge does not have this attribute the weight is set to 1. tree : NetworkX graph or None (default: None) A minimum spanning tree of G. Or, if None, the minimum spanning tree is computed using :func:`networkx.minimum_spanning_tree` Returns ------- list List of nodes in `G` along a cycle with a 3/2-approximation of the minimal Hamiltonian cycle. References ---------- .. [1] Christofides, Nicos. "Worst-case analysis of a new heuristic for the travelling salesman problem." No. RR-388. Carnegie-Mellon Univ Pittsburgh Pa Management Sciences Research Group, 1976. c3(# UHoU4v M g7fN).0ns r christofides..s7JqFJsrc3D># UHup[U5T:gv M g7fr&rr(r)nbrdictNs rr*r+s =}3w<1 }s G must be a complete graph.r"r)nxnodes_with_selfloopsnextcopy remove_edgeremove_edges_from StopIterationranyadjitems NetworkXErrorminimum_spanning_treeremove_nodes_fromdegree MultiGraphadd_edges_fromedgesmin_weight_matching _shortcuttingeulerian_circuit) Gr"tree loop_nodesnodeLvr@MGrCr0s @rrrs?F((+J8J FFH d! 7J77 A A =quu{{} ===<== |''9 ADKKLKyq KLM Bdjj!  " "1 4Ee ,,R0 11)    Ms F 4F F FFc/nUH5up#X1;aM U(dURU5 URU5 M7 URUS5 U$)z"Remove duplicate nodes in the pathr)append)circuitnodesurLs rrErEsK E :  LLO Q   LLq LrTc ~^Uc"UR5(a[nO[nUc[UR5n0m0n[ R "XS9HunupUTU'XU'M UR5(aG[ R"U5(d[ R"S5e[ R"5n O[ R"5n UH)n UH n X:XaM U RXTU U S9 M" M+ U"U 4SU0UD6n U(d_[[U 5U4SjS9upU RU 5S-nXU :wa XSRU 5S-nXU :waM XSU SU-n /n[U 5HupURXkU SS5 M UR!W 5 U$) aVFind the shortest path in `G` connecting specified nodes This function allows approximate solution to the traveling salesman problem on networks that are not complete graphs and/or where the salesman does not need to visit all nodes. This function proceeds in two steps. First, it creates a complete graph using the all-pairs shortest_paths between nodes in `nodes`. Edge weights in the new graph are the lengths of the paths between each pair of nodes in the original graph. Second, an algorithm (default: `christofides` for undirected and `asadpour_atsp` for directed) is used to approximate the minimal Hamiltonian cycle on this new graph. The available algorithms are: - christofides - greedy_tsp - simulated_annealing_tsp - threshold_accepting_tsp - asadpour_atsp Once the Hamiltonian Cycle is found, this function post-processes to accommodate the structure of the original graph. If `cycle` is ``False``, the biggest weight edge is removed to make a Hamiltonian path. Then each edge on the new complete graph used for that analysis is replaced by the shortest_path between those nodes on the original graph. If the input graph `G` includes edges with weights that do not adhere to the triangle inequality, such as when `G` is not a complete graph (i.e length of non-existent edges is infinity), then the returned path may contain some repeating nodes (other than the starting node). Parameters ---------- G : NetworkX graph A possibly weighted graph nodes : collection of nodes (default=G.nodes) collection (list, set, etc.) of nodes to visit weight : string, optional (default="weight") Edge data key corresponding to the edge weight. If any edge does not have this attribute the weight is set to 1. cycle : bool (default: True) Indicates whether a cycle should be returned, or a path. Note: the cycle is the approximate minimal cycle. The path simply removes the biggest edge in that cycle. method : function (default: None) A function that returns a cycle on all nodes and approximates the solution to the traveling salesman problem on a complete graph. The returned cycle is then used to find a corresponding solution on `G`. `method` should be callable; take inputs `G`, and `weight`; and return a list of nodes along the cycle. Provided options include :func:`christofides`, :func:`greedy_tsp`, :func:`simulated_annealing_tsp` and :func:`threshold_accepting_tsp`. If `method is None`: use :func:`christofides` for undirected `G` and :func:`asadpour_atsp` for directed `G`. **kwargs : dict Other keyword arguments to be passed to the `method` function passed in. Returns ------- list List of nodes in `G` along a path with an approximation of the minimal path through `nodes`. Raises ------ NetworkXError If `G` is a directed graph it has to be strongly connected or the complete version cannot be generated. Examples -------- >>> tsp = nx.approximation.traveling_salesman_problem >>> G = nx.cycle_graph(9) >>> G[4][5]["weight"] = 5 # all other weights are 1 >>> tsp(G, nodes=[3, 6]) [3, 2, 1, 0, 8, 7, 6, 7, 8, 0, 1, 2, 3] >>> path = tsp(G, cycle=False) >>> path in ([4, 3, 2, 1, 0, 8, 7, 6, 5], [5, 6, 7, 8, 0, 1, 2, 3, 4]) True While no longer required, you can still build (curry) your own function to provide parameter values to the methods. >>> SA_tsp = nx.approximation.simulated_annealing_tsp >>> method = lambda G, weight: SA_tsp(G, "greedy", weight=weight, temp=500) >>> path = tsp(G, cycle=False, method=method) >>> path in ([4, 3, 2, 1, 0, 8, 7, 6, 5], [5, 6, 7, 8, 0, 1, 2, 3, 4]) True Otherwise, pass other keyword arguments directly into the tsp function. >>> path = tsp( ... G, ... cycle=False, ... method=nx.approximation.simulated_annealing_tsp, ... init_cycle="greedy", ... temp=500, ... ) >>> path in ([4, 3, 2, 1, 0, 8, 7, 6, 5], [5, 6, 7, 8, 0, 1, 2, 3, 4]) True Nr2zG is not strongly connectedr"c >TUSUS$)Nrrr')xdists r,traveling_salesman_problem..Wsd1Q4j16Frkeyr) is_directedr rlistrQr3all_pairs_dijkstrais_strongly_connectedr=DiGraphGraphadd_edgemaxrindexextendrO)rGr"rQcyclemethodkwargspathr)dpGGrRrLbest_GGpos best_pathrVs @rrrs^~ ==??"F!F }QWW  D D**1< 6AQQ= }}''**""#@A A ZZ\ XXZ Av KKT!WQZK 0 R11&1G Xg&,FGmmA"la$-%%a(1,Clab/GDSM1I!CR)" Q r undirectedr)r# mutates_inputc ^SSKJnJn SSKJn [ U5S- mTS:a[ R "S5e[U4SjURR555(a[ R "S5eUb%X0R;a[ R "S 5e[X5upx[U[5(d[[ R"XS 95$[ R "5n UHHupX4U R";dM[%X U UX U U5n U R&"X40X0D6 MJ [)X5n [ R*"U 5n U R#5V V s0sHupX4U"XU 45_M nn n [ R,"XS 5 A AS n[R.n[1SU"U"UR3555-5H9n[5U S US 9nUR7U5nUU:dM'UR95nUnM; [ R:"5nUR#US9H@upnUX U U:XaUR&"X40UU0D6 M+UR&"X40UU0D6 MB UVs0sH'nUUR=U5UR?U5- _M) nn[ R@"UUS5 [ RB"US5nUR5HUunnUHInUU4UR";dMUUS:dM"[1UU5HnUR'UU5 M MK MW [ R"UUS 9n[U5$s sn n fs snf)u Returns an approximate solution to the traveling salesman problem. This approximate solution is one of the best known approximations for the asymmetric traveling salesman problem developed by Asadpour et al, [1]_. The algorithm first solves the Held-Karp relaxation to find a lower bound for the weight of the cycle. Next, it constructs an exponential distribution of undirected spanning trees where the probability of an edge being in the tree corresponds to the weight of that edge using a maximum entropy rounding scheme. Next we sample that distribution $2 \lceil \ln n \rceil$ times and save the minimum sampled tree once the direction of the arcs is added back to the edges. Finally, we augment then short circuit that graph to find the approximate tour for the salesman. Parameters ---------- G : nx.DiGraph The graph should be a complete weighted directed graph. The distance between all paris of nodes should be included and the triangle inequality should hold. That is, the direct edge between any two nodes should be the path of least cost. weight : string, optional (default="weight") Edge data key corresponding to the edge weight. If any edge does not have this attribute the weight is set to 1. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. source : node label (default=`None`) If given, return the cycle starting and ending at the given node. Returns ------- cycle : list of nodes Returns the cycle (list of nodes) that a salesman can follow to minimize the total weight of the trip. Raises ------ NetworkXError If `G` is not complete or has less than two nodes, the algorithm raises an exception. NetworkXError If `source` is not `None` and is not a node in `G`, the algorithm raises an exception. NetworkXNotImplemented If `G` is an undirected graph. References ---------- .. [1] A. Asadpour, M. X. Goemans, A. Madry, S. O. Gharan, and A. Saberi, An o(log n/log log n)-approximation algorithm for the asymmetric traveling salesman problem, Operations research, 65 (2017), pp. 1043–1061 Examples -------- >>> import networkx as nx >>> import networkx.algorithms.approximation as approx >>> G = nx.complete_graph(3, create_using=nx.DiGraph) >>> nx.set_edge_attributes( ... G, ... {(0, 1): 2, (1, 2): 2, (2, 0): 2, (0, 2): 1, (2, 1): 1, (1, 0): 1}, ... "weight", ... ) >>> tour = approx.asadpour_atsp(G, source=0) >>> tour [0, 2, 1, 0] r)ceilexplogrrzG must have at least two nodesc3N># UHup[U5X;- T:gv M g7fr&r-r.s rr* asadpour_atsp..# N *!3w<1< (A - "%zG is not a complete DiGraphNzGiven source node not in G.)sourcer")rdatademand)"mathrsrtrvrr3r=r:r;r<rQheld_karp_ascent isinstancedictrErFrArCminrbspanning_tree_distributionraset_edge_attributesinfrnumber_of_nodesrsizer6 MultiDiGraph out_degree in_degreeset_node_attributes min_cost_flow)rGr"rr{rsrtlnopt_hkz_star z_supportrRrL edge_weightgamma lambda_dictminimum_sampled_treeminimum_sampled_tree_weight_ sampled_treesampled_tree_weightt_starrjr) node_demands flow_dictvaluestargetrPr0s @rr r ds8\ A A1u?@@ N NNN<== fGG3<==%a0NF fd # #R00GHH I 6 (ad1gfoqtAwv?K   q ='< = 'y 9E#I:C//:KL:K$!A63uV}--:KKL98< { "&(( 1tBq002344 5+IxdK *//7 !< <#/#4#4#6 *= ' 6__ F'--6-:a Q  OOA 0VQK 0 OOA 0VQK 0 ;LRR6aAv((+f.>.>q.AAA6LR1lH5  H-I$//+Fv||3v8Jvf~.AOOFF3/,!!&8G  !!OM.Ss N.N)r#rq returns_graphc b^^^^^SSKmSSKJm UU4SjmUUUU4SjnUU4Sjn0nTHnSXE'M A0nTRSS9Hupxn U TXgU4'M U"5upU bdU"X5n U R 5HupXXE==X-- ss'M TRSS9Hupxn XgU4XG-U T'M U"5upU bMd[ R "T5 U n U H\n[UVs/sHo^RU5S :XdMUPM sn5TR5:XdMIURT5U4s $ 0n[U 5nTRSS9HMupxn SnXgU4U T'U H-nXx4UR5;dMUS - nXgU4XUT'M/ UU- XU4'MO 0nTR5S - TR5- nUH#upxXU4XU4-nUS:dMUU-UXx4'M% A[U R55RT5U4$s snf) ul Minimizes the Held-Karp relaxation of the TSP for `G` Solves the Held-Karp relaxation of the input complete digraph and scales the output solution for use in the Asadpour [1]_ ASTP algorithm. The Held-Karp relaxation defines the lower bound for solutions to the ATSP, although it does return a fractional solution. This is used in the Asadpour algorithm as an initial solution which is later rounded to a integral tree within the spanning tree polytopes. This function solves the relaxation with the branch and bound method in [2]_. Parameters ---------- G : nx.DiGraph The graph should be a complete weighted directed graph. The distance between all paris of nodes should be included. weight : string, optional (default="weight") Edge data key corresponding to the edge weight. If any edge does not have this attribute the weight is set to 1. Returns ------- OPT : float The cost for the optimal solution to the Held-Karp relaxation z : dict or nx.Graph A symmetrized and scaled version of the optimal solution to the Held-Karp relaxation for use in the Asadpour algorithm. If an integral solution is found, then that is an optimal solution for the ATSP problem and that is returned instead. References ---------- .. [1] A. Asadpour, M. X. Goemans, A. Madry, S. O. Gharan, and A. Saberi, An o(log n/log log n)-approximation algorithm for the asymmetric traveling salesman problem, Operations research, 65 (2017), pp. 1043–1061 .. [2] M. Held, R. M. Karp, The traveling-salesman problem and minimum spanning trees, Operations Research, 1970-11-01, Vol. 18 (6), pp.1138-1162 rN)optimizec <>TR5n[5n[Rn[ TR 55nUR U5 SST[R0nSST[R*0nTRUSS9H2upgnUTUT:a SUTUT0nUTUT:dM)SUTUT0nM4 [TRUSS9U4SjS9n UTU ST-UT'UTU ST-UT'[Rn [R"U5GHgn U RT5n U [R:XaU n OXUT-UT- :a U$U RH9upUS:XdM U R"X=40TTUU T0D6 U TUU T- n O TW UnTRX5 [TRUTS9S S9SnTRUTS9VVVs/sHupgoU:XdM XgU4PM nnnnUH`upgnU R5nUR"Xg40TU0D6 X-nUU:aUR!5 UnUU:XdMOUR#U5 Mb TR"X40UD6 GMj U$s snnnf) zx Find the set of minimum 1-Arborescences for G at point pi. Returns ------- Set The set of minimum 1-Arborescences rJNTr|c>UST$Nrr')rUr"s rrW0held_karp_ascent..k_pi..Ss !A$v,rrYrrc US$rr')rUs rrWrosqtr)r6setrrr5__iter__ remove_noderCrin_edgesr3ArborescenceIteratorrrrbr7clearadd)G_1minimum_1_arborescencesminimum_1_arborescence_weightr)min_rootmax_rootrRrLrj min_in_edgemin_arb_weightarb arb_weightr0deg edge_data min_weight min_edgesnew_arbnew_arb_weightrGr"s rk_piheld_karp_ascent..k_pi1sffh"%%(,%   D&$((3D&488)4wwqtw,GA!y8F++"Avqy9y8F++"Avqy9 - !**QT*28NO #F+k!nV.DD#F+k!nV.DD**3/C&)J)!+x/??(6BRRRL'&E--!8LLC&!A$q'&/)BC!A$q'&/1J (!QI MM! QZZZ7^LQOJ)*AF)C)CgaAJ q )C %a((*  5&!5!+ "$AA+1134B1!%BB+//8% JJq )y )S0V'&'s ; J J c>0nTHnSX'M AT"5n[RnSnUH2nSnURHupX`UUS- -- nM Xc:dM.UnUnM4 US:aX4$URHupX==US- - ss'M TR[ U5S[ S9nTR [ T5S-[ U54[ S9n TR[ T5S-[ S9n SU [ T5'[U5HHup[ T5S- n URHupUS- XU 'U S-n M SU [ T5U 'MJ TRXU SS9n U R(aSU4$GMn) ah Find the direction of ascent at point pi. See [1]_ for more information. Returns ------- dict A mapping from the nodes of the graph which represents the direction of ascent. References ---------- .. [1] M. Held, R. M. Karp, The traveling-salesman problem and minimum spanning trees, Operations Research, 1970-11-01, Vol. 18 (6), pp.1138-1162 rNrr[)dtyperz highs-ipm)A_eqb_eqrg) rrr@fullrintemptyzeros enumeratelinprogsuccess)rjr)rmin_k_d_weightmin_k_d arborescence weighted_costrca_eqr arb_countn_countprogram_resultrGrnprs rdirection_of_ascent-held_karp_ascent..direction_of_ascents& AAD "&&"XXNG 7 ! *11FA!qTS1W%55M2 1%2N*G !8!z!!..a) 34bDA88SVaZ-D)EFc8RD88CFQJc82DDQL+45L+M' a&1**11FA/2QwDM),qLG2+,SV Y' ,N &--4 .N%%444Orc>[RnT RT S9GHgup4nX44UR;aM[UR UT S95S:a[ e[ UR UT S9R55upgnUR"X440T U0D6 URXg5 [SUR555S::a[T 5UR5:Xas[R"U5(aXXX:XdX:Xa)URX45 UR"Xg40T U0D6 GM!X- XX- - n SU s=:aU:aO OU nURX45 UR"Xg40T U0D6 GMj U$)aR Given the direction of ascent at pi, find the maximum distance we can go in that direction. Parameters ---------- k_xy : set The set of 1-arborescences which have the minimum rate of increase in the direction of ascent d : dict The direction of ascent Returns ------- float The distance we can travel in direction `d` r|rc3*# UH upUv M g7fr&r')r(r)rjs rr*9held_karp_ascent..find_epsilon..s0-$!A-sr)rrrCrr Exceptionr5rrbr7rcrnumber_of_edgesr3is_weakly_connected) rrj min_epsilone_ue_ve_wsub_usub_vsub_wepsilonrGr"s r find_epsilon&held_karp_ascent..find_epsilonsf&hh WW&W1MCczQWW$1::c:/014"&qzz#Fz'C'L'L'N"O E% JJs 1FC= 1 MM% '0!++-00A5Fa//11**1--8qv%MM#+JJu?? ;16AH+<=w,,")K MM# # JJu 7 7A2DrTr|rr) numpyscipyrrCr<r3 _clear_cacherr@orderrr5r)rGr"rrpi_dictr)original_edge_weightsrRrLrj dir_ascentk_d max_distancek_maxrx_star size_k_max edge_countr scale_factor frequencyrrrs`` @@@rrrse\R'h@5@5H6vG   777%a()& !f%&)+OJ  #C4 $$&DA J,* *J'wwDw)GA!-!f5 BAfI*-/  OOA E 111a q 011 2aggi ?66&>1$ $ FUJ777%a )a&1& Av"a "7A"?Q$j01v&FGGIMQWWY.Lq6NVF^3 q=)I5FA6N   ! & &v . 6692s 1H, H, cH^^^^SSKJm SSKJn UUUU4Sjn0mTRH upEnSTXE4'M SnSmSnTHupEXE4n U"U 5n Xn U SU-U -:aU"U SSUS - -U -- -SU - SUS - --U -- 5n TU ==U -ss'U"U 5n SUS - -U -n[ U S 5[ US 5:wa[ R "S US US 35eMUS- nM U[T5:XaOMTRSS9Hu poTU;dMUT M T$)a Find the asadpour exponential distribution of spanning trees. Solves the Maximum Entropy Convex Program in the Asadpour algorithm [1]_ using the approach in section 7 to build an exponential distribution of undirected spanning trees. This algorithm ensures that the probability of any edge in a spanning tree is proportional to the sum of the probabilities of the tress containing that edge over the sum of the probabilities of all spanning trees of the graph. Parameters ---------- G : nx.MultiGraph The undirected support graph for the Held Karp relaxation z : dict The output of `held_karp_ascent()`, a scaled version of the Held-Karp solution. Returns ------- gamma : dict The probability distribution which approximately preserves the marginal probabilities of `z`. r)rtruc>TRSS9HupnT"T X45UT 'M [R"TT 5n[R"TUSS9n[R"UT 5nT"T USUS45U-U- $)a The value of q(e) is described in the Asadpour paper is "the probability that edge e will be included in a spanning tree T that is chosen with probability proportional to exp(gamma(T))" which basically means that it is the total probability of the edge appearing across the whole distribution. Parameters ---------- e : tuple The `(u, v)` tuple describing the edge we are interested in Returns ------- float The probability that a spanning tree chosen according to the current values of gamma will include edge `e`. Tr|F) self_loopsrr)rCr3total_spanning_tree_weightcontracted_edge) erRrLrj G_KirchhoffG_e G_e_KirchhoffrGrtr lambda_keys rq%spanning_tree_distribution..q[s(wwDw)GA!qf .AjM*33AzB   A%855c:F 5!A$!&'-7+EErg?z=spanning_tree_distribution's secret attribute name for lambdaTrrz'Unable to modify probability for edge (z, )r|)rrtrvrCroundr3r=r)rGzrrrRrLrEPSILONin_range_countrq_ez_edeltanew_q_e desired_q_erjrtrrs` @@@rrr;s:FF> E77aqf GQJ  DAAA$C$Ca'kS((AWq[C 778CA! O4s:<aE!A$ 7Q;#5 !$k1(==**A!BqcK> !#%( SZ ' 9 >777%1 ?* & LrcT^^^[U5S- m[U4SjURR555(a[R "S5eUc[R RU5nUR5S:Xa[URU55nX#U/$[U5nURU5 U/nUnU(a>Xm[UUU4SjS9nURU5 URU5 U(aM>URUS5 U$)a Return a low cost cycle starting at `source` and its cost. This approximates a solution to the traveling salesman problem. It finds a cycle of all the nodes that a salesman can visit in order to visit many nodes while minimizing total distance. It uses a simple greedy algorithm. In essence, this function returns a large cycle given a source point for which the total cost of the cycle is minimized. Parameters ---------- G : Graph The Graph should be a complete weighted undirected graph. The distance between all pairs of nodes should be included. weight : string, optional (default="weight") Edge data key corresponding to the edge weight. If any edge does not have this attribute the weight is set to 1. source : node, optional (default: first node in list(G)) Starting node. If None, defaults to ``next(iter(G))`` Returns ------- cycle : list of nodes Returns the cycle (list of nodes) that a salesman can follow to minimize total weight of the trip. Raises ------ NetworkXError If `G` is not complete, the algorithm raises an exception. Examples -------- >>> from networkx.algorithms import approximation as approx >>> G = nx.DiGraph() >>> G.add_weighted_edges_from( ... { ... ("A", "B", 3), ... ("A", "C", 17), ... ("A", "D", 14), ... ("B", "A", 3), ... ("B", "C", 12), ... ("B", "D", 16), ... ("C", "A", 13), ... ("C", "B", 12), ... ("C", "D", 4), ... ("D", "A", 14), ... ("D", "B", 15), ... ("D", "C", 2), ... } ... ) >>> cycle = approx.greedy_tsp(G, source="D") >>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle)) >>> cycle ['D', 'C', 'B', 'A', 'D'] >>> cost 31 Notes ----- This implementation of a greedy algorithm is based on the following: - The algorithm adds a node to the solution at every iteration. - The algorithm selects a node not already in the cycle whose connection to the previous node adds the least cost to the cycle. A greedy algorithm does not always give the best solution. However, it can construct a first feasible solution which can be passed as a parameter to an iterative improvement algorithm such as Simulated Annealing, or Threshold Accepting. Time complexity: It has a running time $O(|V|^2)$ rc3N># UHup[U5X;- T:gv M g7fr&r-r.s rr*greedy_tsp..ryrzr1rc.>TURTS5$)Nrget)r)r/r"s rrWgreedy_tsp.. swqz~~fa/HrrYr)rr:r;r<r3r=utilsarbitrary_elementrr5 neighborsrremoverrO) rGr"r{neighbornodesetrf next_noder0r/s ` @@rr r s\ A A N NNN<== ~++A.a F+,&))!fG NN6 HEI ,%HI  Yy! '  LLq Lr c ^^^US:Xa[nO US:Xa[nUS:Xa#[TTUS9n TR5S:XaU $GO=[ U5n UcU SnOX:S:wa[ R "S5eU SU S:wa[ R "S 5e[U 5S - [T5:wd0[[TRU 555[T5:wa[ R "S 5e[T5S - m[U4S jTRR555(a[ R "S 5eTR5S:Xa[TRU55n X;U/$[UU4Sj[!U 555n Sn U R#5nU nX::aUS:aU S - n [%U5HnU"X5n[UU4Sj[!U555nUU - nUS::a!Un Un X:aSn U R#5nU nMTMV[&R("U*U- 5nUU R+5:dMUn Un M XDU--nX::aUS:aMU$)aReturns an approximate solution to the traveling salesman problem. This function uses simulated annealing to approximate the minimal cost cycle through the nodes. Starting from a suboptimal solution, simulated annealing perturbs that solution, occasionally accepting changes that make the solution worse to escape from a locally optimal solution. The chance of accepting such changes decreases over the iterations to encourage an optimal result. In summary, the function returns a cycle starting at `source` for which the total cost is minimized. It also returns the cost. The chance of accepting a proposed change is related to a parameter called the temperature (annealing has a physical analogue of steel hardening as it cools). As the temperature is reduced, the chance of moves that increase cost goes down. Parameters ---------- G : Graph `G` should be a complete weighted graph. The distance between all pairs of nodes should be included. init_cycle : list of all nodes or "greedy" The initial solution (a cycle through all nodes returning to the start). This argument has no default to make you think about it. If "greedy", use `greedy_tsp(G, weight)`. Other common starting cycles are `list(G) + [next(iter(G))]` or the final result of `simulated_annealing_tsp` when doing `threshold_accepting_tsp`. weight : string, optional (default="weight") Edge data key corresponding to the edge weight. If any edge does not have this attribute the weight is set to 1. source : node, optional (default: first node in list(G)) Starting node. If None, defaults to ``next(iter(G))`` temp : int, optional (default=100) The algorithm's temperature parameter. It represents the initial value of temperature move : "1-1" or "1-0" or function, optional (default="1-1") Indicator of what move to use when finding new trial solutions. Strings indicate two special built-in moves: - "1-1": 1-1 exchange which transposes the position of two elements of the current solution. The function called is :func:`swap_two_nodes`. For example if we apply 1-1 exchange in the solution ``A = [3, 2, 1, 4, 3]`` we can get the following by the transposition of 1 and 4 elements: ``A' = [3, 2, 4, 1, 3]`` - "1-0": 1-0 exchange which moves an node in the solution to a new position. The function called is :func:`move_one_node`. For example if we apply 1-0 exchange in the solution ``A = [3, 2, 1, 4, 3]`` we can transfer the fourth element to the second position: ``A' = [3, 4, 2, 1, 3]`` You may provide your own functions to enact a move from one solution to a neighbor solution. The function must take the solution as input along with a `seed` input to control random number generation (see the `seed` input here). Your function should maintain the solution as a cycle with equal first and last node and all others appearing once. Your function should return the new solution. max_iterations : int, optional (default=10) Declared done when this number of consecutive iterations of the outer loop occurs without any change in the best cost solution. N_inner : int, optional (default=100) The number of iterations of the inner loop. alpha : float between (0, 1), optional (default=0.01) Percentage of temperature decrease in each iteration of outer loop seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Returns ------- cycle : list of nodes Returns the cycle (list of nodes) that a salesman can follow to minimize total weight of the trip. Raises ------ NetworkXError If `G` is not complete the algorithm raises an exception. Examples -------- >>> from networkx.algorithms import approximation as approx >>> G = nx.DiGraph() >>> G.add_weighted_edges_from( ... { ... ("A", "B", 3), ... ("A", "C", 17), ... ("A", "D", 14), ... ("B", "A", 3), ... ("B", "C", 12), ... ("B", "D", 16), ... ("C", "A", 13), ... ("C", "B", 12), ... ("C", "D", 4), ... ("D", "A", 14), ... ("D", "B", 15), ... ("D", "C", 2), ... } ... ) >>> cycle = approx.simulated_annealing_tsp(G, "greedy", source="D") >>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle)) >>> cycle ['D', 'C', 'B', 'A', 'D'] >>> cost 31 >>> incycle = ["D", "B", "A", "C", "D"] >>> cycle = approx.simulated_annealing_tsp(G, incycle, source="D") >>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle)) >>> cycle ['D', 'C', 'B', 'A', 'D'] >>> cost 31 Notes ----- Simulated Annealing is a metaheuristic local search algorithm. The main characteristic of this algorithm is that it accepts even solutions which lead to the increase of the cost in order to escape from low quality local optimal solutions. This algorithm needs an initial solution. If not provided, it is constructed by a simple greedy algorithm. At every iteration, the algorithm selects thoughtfully a neighbor solution. Consider $c(x)$ cost of current solution and $c(x')$ cost of a neighbor solution. If $c(x') - c(x) <= 0$ then the neighbor solution becomes the current solution for the next iteration. Otherwise, the algorithm accepts the neighbor solution with probability $p = exp - ([c(x') - c(x)] / temp)$. Otherwise the current solution is retained. `temp` is a parameter of the algorithm and represents temperature. Time complexity: For $N_i$ iterations of the inner loop and $N_o$ iterations of the outer loop, this algorithm has running time $O(N_i * N_o * |V|)$. For more information and how the algorithm is inspired see: http://en.wikipedia.org/wiki/Simulated_annealing 1-11-0greedyr"r{rr'source must be first node in init_cycler[-init_cycle must be a cycle. (return to start)rz1init_cycle should be a cycle over all nodes in G.c3N># UHup[U5X;- T:gv M g7fr&r-r.s rr**simulated_annealing_tsp..#RMjas7|q|,1Mrzr1c3X># UHupTUURTS5v M! g7frNrr(rRrLrGr"s rr*r#)B/$!qtAw{{61%%/'*c3X># UHupTUURTS5v M! g7fr&rr's rr*r#+P>Oda1Q47;;vq11>Or))rr r rr]r3r=rr nbunch_iterr:r;r<r5rsumrr6rrrtrandom)rG init_cycler"r{tempmovemax_iterationsN_inneralpharrfrcostcount best_cycle best_costiadj_soladj_costr rkr0s` ` @rr r sOL u} X1VF;   ! #L $Z  >1XF Qx ""#LM M 8uRy ""#RS S u:>SV #s3q}}U/C+D'EQ'O""#VW W FQJ RAEEKKMR R R""#@A A   ! #AKK/0Hf- - B(5/B BD EJI  !dQh  wA5'GPhw>OPPHtOEz#E!&J $I$ HHeVd]+ %#E#D% & u +  !dQh. rc ^^^US:Xa[nO US:Xa[nUS:Xa#[TTUS9n TR5S:XaU $GO@[ U5n UcU SnOX:S:wa[ R "S5eU SU S:wa[ R "S 5e[U 5S - [T5:wd0[[TRU 555[T5:wa[ R "S 5e[T5S - m[U4S jTRR555(a[ R "S 5eTR5S:Xa![ TRU55Sn X;U/$[UU4Sj[U 555n Sn U R!5nU nX::aU S - n Sn[#U5HXnU"X5n[UU4Sj[U555nUU - nUU::dM7SnUn Un X:dMDSn U R!5nU nMZ U(aXDU--nX::aMU$)aReturns an approximate solution to the traveling salesman problem. This function uses threshold accepting methods to approximate the minimal cost cycle through the nodes. Starting from a suboptimal solution, threshold accepting methods perturb that solution, accepting any changes that make the solution no worse than increasing by a threshold amount. Improvements in cost are accepted, but so are changes leading to small increases in cost. This allows the solution to leave suboptimal local minima in solution space. The threshold is decreased slowly as iterations proceed helping to ensure an optimum. In summary, the function returns a cycle starting at `source` for which the total cost is minimized. Parameters ---------- G : Graph `G` should be a complete weighted graph. The distance between all pairs of nodes should be included. init_cycle : list or "greedy" The initial solution (a cycle through all nodes returning to the start). This argument has no default to make you think about it. If "greedy", use `greedy_tsp(G, weight)`. Other common starting cycles are `list(G) + [next(iter(G))]` or the final result of `simulated_annealing_tsp` when doing `threshold_accepting_tsp`. weight : string, optional (default="weight") Edge data key corresponding to the edge weight. If any edge does not have this attribute the weight is set to 1. source : node, optional (default: first node in list(G)) Starting node. If None, defaults to ``next(iter(G))`` threshold : int, optional (default=1) The algorithm's threshold parameter. It represents the initial threshold's value move : "1-1" or "1-0" or function, optional (default="1-1") Indicator of what move to use when finding new trial solutions. Strings indicate two special built-in moves: - "1-1": 1-1 exchange which transposes the position of two elements of the current solution. The function called is :func:`swap_two_nodes`. For example if we apply 1-1 exchange in the solution ``A = [3, 2, 1, 4, 3]`` we can get the following by the transposition of 1 and 4 elements: ``A' = [3, 2, 4, 1, 3]`` - "1-0": 1-0 exchange which moves an node in the solution to a new position. The function called is :func:`move_one_node`. For example if we apply 1-0 exchange in the solution ``A = [3, 2, 1, 4, 3]`` we can transfer the fourth element to the second position: ``A' = [3, 4, 2, 1, 3]`` You may provide your own functions to enact a move from one solution to a neighbor solution. The function must take the solution as input along with a `seed` input to control random number generation (see the `seed` input here). Your function should maintain the solution as a cycle with equal first and last node and all others appearing once. Your function should return the new solution. max_iterations : int, optional (default=10) Declared done when this number of consecutive iterations of the outer loop occurs without any change in the best cost solution. N_inner : int, optional (default=100) The number of iterations of the inner loop. alpha : float between (0, 1), optional (default=0.1) Percentage of threshold decrease when there is at least one acceptance of a neighbor solution. If no inner loop moves are accepted the threshold remains unchanged. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Returns ------- cycle : list of nodes Returns the cycle (list of nodes) that a salesman can follow to minimize total weight of the trip. Raises ------ NetworkXError If `G` is not complete the algorithm raises an exception. Examples -------- >>> from networkx.algorithms import approximation as approx >>> G = nx.DiGraph() >>> G.add_weighted_edges_from( ... { ... ("A", "B", 3), ... ("A", "C", 17), ... ("A", "D", 14), ... ("B", "A", 3), ... ("B", "C", 12), ... ("B", "D", 16), ... ("C", "A", 13), ... ("C", "B", 12), ... ("C", "D", 4), ... ("D", "A", 14), ... ("D", "B", 15), ... ("D", "C", 2), ... } ... ) >>> cycle = approx.threshold_accepting_tsp(G, "greedy", source="D") >>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle)) >>> cycle ['D', 'C', 'B', 'A', 'D'] >>> cost 31 >>> incycle = ["D", "B", "A", "C", "D"] >>> cycle = approx.threshold_accepting_tsp(G, incycle, source="D") >>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle)) >>> cycle ['D', 'C', 'B', 'A', 'D'] >>> cost 31 Notes ----- Threshold Accepting is a metaheuristic local search algorithm. The main characteristic of this algorithm is that it accepts even solutions which lead to the increase of the cost in order to escape from low quality local optimal solutions. This algorithm needs an initial solution. This solution can be constructed by a simple greedy algorithm. At every iteration, it selects thoughtfully a neighbor solution. Consider $c(x)$ cost of current solution and $c(x')$ cost of neighbor solution. If $c(x') - c(x) <= threshold$ then the neighbor solution becomes the current solution for the next iteration, where the threshold is named threshold. In comparison to the Simulated Annealing algorithm, the Threshold Accepting algorithm does not accept very low quality solutions (due to the presence of the threshold value). In the case of Simulated Annealing, even a very low quality solution can be accepted with probability $p$. Time complexity: It has a running time $O(m * n * |V|)$ where $m$ and $n$ are the number of times the outer and inner loop run respectively. For more information and how algorithm is inspired see: https://doi.org/10.1016/0021-9991(90)90201-B See Also -------- simulated_annealing_tsp rrrrrrr r[r!rz%init_cycle is not all and only nodes.c3N># UHup[U5X;- T:gv M g7fr&r-r.s rr**threshold_accepting_tsp..r$rzr1c3X># UHupTUURTS5v M! g7fr&rr's rr*r>r(r)Fc3X># UHupTUURTS5v M! g7fr&rr's rr*r>r+r)T)rr r rr]r3r=rrr,r:r;r<rr-rr6r)rGr/r"r{ thresholdr1r2r3r4rrfrr5r6r7r8acceptedr9r:r;r r0s` ` @rr r s&V u} X1VF;   ! #L $Z  >1XF Qx ""#LM M 8uRy ""#RS S u:>SV #s3q}}U/C+D'EQ'O""#JK K FQJ RAEEKKMR R R""#@A A   ! #AKK/03Hf- - B(5/B BD EJI  !  wA5'GPhw>OPPHtOE ! #E!&J $I   U* *I'  !* r)r"N)r"NTN)r"NNr2)r"Ndr rCg{Gz?N)r"NrrrDrCg?N)__doc__rnetworkxr3networkx.algorithms.tree.mstrnetworkx.utilsrrr__all__rr _dispatchablerrErr rrr r r r'rrrKs"H =II  F$NZ X&82'!82v X&7;W'Wt\"XT:V";#V"rXTNw7Ow7t kk\X&c'cLX&      a'aHX&     d'dr