Hej där! Som en TSP (tripolyfosfat) leverantör får jag ofta frågad om hur man implementerar TSP -algoritmer i Python. Det är ett ganska coolt ämne, och jag är ständig att dela min kunskap med dig.
Vad är TSP?
Först och främst, låt oss snabbt täcka vad det resande säljarproblemet (TSP) är. Föreställ dig att du är en säljare som behöver besöka ett gäng städer. Du vill hitta den kortast möjliga rutten som besöker varje stad exakt en gång och sedan återvänder till startstaden. Det kan låta enkelt, men när antalet städer växer blir det att hitta den optimala lösningen ett riktigt huvud. Det är där TSP -algoritmer kommer in.
Varför Python?
Python är ett fantastiskt språk för att implementera TSP -algoritmer. Det är superlätt att lära sig, har massor av bibliotek tillgängliga och kan hantera komplexa beräkningar utan för mycket besvär. Oavsett om du är nybörjare eller en erfaren kodare gör Python det relativt enkelt att få händerna smutsiga med TSP -algoritmer.
Implementera det naiva tillvägagångssättet
Det enklaste sättet att lösa TSP är det naiva tillvägagångssättet. I denna metod genererar vi alla möjliga permutationer av städerna och beräknar det totala avståndet för varje permutation. Då väljer vi bara det med det kortaste avståndet.
Här är ett enkelt Python -kodavsnitt för att illustrera det naiva tillvägagångssättet:
import itertools def distance(city1, city2): # Here you'd calculate the actual distance between two cities # For simplicity, let's assume we have a simple Euclidean distance return ((city1[0] - city2[0])**2+(city1[1] - city2[1])**2)**0.5 def tsp_naive(cities): all_permutations = list(itertools.permutations(cities)) min_distance = float('inf') best_route = None for route in all_permutations: total_distance = 0 for i in range(len(route) - 1): total_distance += distance(route[i], route[i+1]) total_distance += distance(route[-1], route[0]) # Return to the starting city if total_distance <min_distance: min_distance = total_distance best_route = route return min_distance, best_route # exempelanvändning städer = [(0, 0), (1, 5), (2, 3)] min_dist, best_route = tsp_naive (cities) tryck (f "the minimum avstånd är {min_dist}}}} {)Problemet med det naiva tillvägagångssättet är att det har en tidskomplexitet av O (n!), Där n är antalet städer. Detta innebär att när antalet städer ökar blir algoritmen extremt långsam.
Använda närmaste grannalgoritm
Den närmaste grannalgoritmen är en girig algoritm som ger en snabb men inte alltid optimal lösning. Den börjar i en slumpmässig stad och besöker sedan upprepade gånger den närmaste oöverträffade staden tills alla städer har besökts. Slutligen återvänder den till startstaden.
def tsp_nearest_neighbor (städer): current_city = städer [0] unisited = set (städer [1:]) route = [current_city] medan unisited: närmaste_city = min (unwyned, nyckel = lambda stad: avstånd (aktuell, stad)) rutt.append (närmaste) unse.remove (närmaste_city) current = current = currenty = currenty = currenty = currenty = currentyity) routeyity) route.append(cities[0]) # Return to the starting city total_distance = 0 for i in range(len(route) - 1): total_distance += distance(route[i], route[i+1]) return total_distance, route # Example usage cities = [(0, 0), (1, 5), (2, 3)] min_dist, best_route = tsp_nearest_neighbor(cities) utskrift (F "Minsta avståndet är {min_dist} och den bästa rutten är {Best_Route}")Den närmaste grannalgoritmen har en tidskomplexitet av O (n^2), vilket är mycket bättre än det naiva tillvägagångssättet för större antal städer. Men det ger inte alltid den optimala lösningen.
Den dynamiska programmeringsmetoden
Dynamisk programmering kan användas för att lösa TSP mer effektivt för mindre problemstorlekar. Den grundläggande idén är att dela upp problemet i mindre underproblem och lagra lösningarna på dessa underproblem för att undvika redundanta beräkningar.
från functools importerar lru_cache @lru_cache (maxSize = none) def tsp_dp (mask, pos, dist_matrix): num_cities = len (dist_matrix) om mask == (1 <<num_cities) - 1: return dist_matrix [pos] [0] ans = flottör ('indriva) (1 << next_city)) == 0: new_mask = mask | (1 << next_city) new_cost = dist_matrix [pos] [next_city]+tsp_dp (new_mask, next_city, dist_matrix) Ans = min (Ans, new_cost) return ANS # Exempel Användning Cities = [(0, 0), (1, 5), (2, 3)] Dist_matix = [Distantera ([Exempel Användning Cities = [(0, 0), (1, 5), (2) stad1 i städer] min_dist = tsp_dp (1, 0, tuple (karta (tuple, dist_matrix))) tryck (f "minsta avståndet är {min_dist}")Den dynamiska programmeringsmetoden har en tidskomplexitet av O (n^2 * 2^n), vilket är bättre än den naiva tillvägagångssättet men som fortfarande inte är lämpligt för mycket stort antal städer.
Våra TSP -produkter
Som TSP -leverantör erbjuder vi en rad produkter av hög kvalitet. Till exempel har vi detNatriumtripolyfosfat 95% STPP livsmedelsgrad som vattenhållningsmedel. Denna produkt används ofta i livsmedelsindustrin som ett vattenhållningsmedel, vilket hjälper till att hålla maten fräsch och fuktig.
Vi har ocksåMonopotassiumfosfatmatingrediens MKP mono kaliumfosfat. Det är en viktig livsmedelsingrediens som kan användas i olika livsmedelsapplikationer.
Och vårBästsäljande DISODIUM -fosfat (DSP) Matklass NA2HPO4 DSPär en topp -säljare, känd för sin höga kvalitet och effektivitet i livsmedelsbearbetningen.
Inpackning
Att implementera TSP -algoritmer i Python kan vara en rolig och givande upplevelse. Oavsett om du använder det naiva tillvägagångssättet, den närmaste grannalgoritmen eller dynamisk programmering, har varje metod sina egna för- och nackdelar. När antalet städer ökar måste du välja den algoritm som bäst passar dina behov när det gäller både tidskomplexitet och lösningsoptimalitet.
Om du är intresserad av våra TSP -produkter eller har några frågor om TSP -algoritmer, känn dig fri att nå ut. Vi är alltid glada att hjälpa till med dina TSP -relaterade behov och diskutera potentiella affärsmöjligheter.
Referenser
- Cormen, TH, Leison, CE, Rivest, RL, & Stein, C. (2009). Introduktion till algoritmer. Med press.
- Skiena, SS (2020). Algoritmdesignhandboken. Springer.