Ei! Como fornecedor de TSP (Tripolifosfato), muitas vezes me perguntam sobre como implementar algoritmos de TSP no Python. É um tópico bem legal, e estou feliz em compartilhar meu conhecimento com você.
Qual é o TSP?
Primeiro, vamos abordar rapidamente o que é o problema do vendedor ambulante (TSP). Imagine que você é um vendedor que precisa visitar um monte de cidades. Você deseja encontrar a rota mais curta possível que visita cada cidade exatamente uma vez e depois retorne à cidade inicial. Pode parecer simples, mas à medida que o número de cidades cresce, encontrar a solução ideal se torna uma verdadeira cabeça - arranhadora. É aí que entram os algoritmos de TSP.
Por que Python?
O Python é um idioma incrível para a implementação de algoritmos de TSP. É super fácil de aprender, tem uma tonelada de bibliotecas disponíveis e pode lidar com cálculos complexos sem muito aborrecimento. Seja você iniciante ou um codificador experiente, o Python torna relativamente simples sujar as mãos com algoritmos de TSP.
Implementando a abordagem ingênua
A maneira mais simples de resolver o TSP é a abordagem ingênua. Neste método, geramos todas as permutações possíveis das cidades e calculamos a distância total para cada permutação. Então apenas escolhemos o que é mais curto.
Aqui está um snippet de código Python simples para ilustrar a abordagem ingênua:
Importar ITERTOOLS DEF DISTÊNCIA (City1, City2): # Aqui você calcularia a distância real entre duas cidades # para simplificar, vamos assumir que temos um retorno simples da distância euclidiana ((City1 [0] - City2 [0]) ** 2+ (City1 [1] - City2 [1]) ** 2) ** 0.5 tsp_nine (1] - City2 [1]) ** 2) ** 0.5 tsp_nine (1] - [1]) ** 2) ** 0.5 tsp_nine (1] - [1] ** 2) ** 0.5 0.5 Tsp_nive (1] - [1] ** 2) ** 0.5 0.5 Tsp_Naive (1] - [1] ** 2) ** 0.5 0.5 Tsp_Naive (1] - [1] ** 2) ** 0.5 0.5 Tsp_Naive (1] - [1]) ** 2) ** 0.5 de def LIST (ITERTOOLS.PERMUTATIONS (CIDADES)) min_distance = float ('inf') best_route = Nenhum para rota em all_permutações: total_distance = 0 para i no intervalo (len (rota) - 1): total_distância += distância (rota [i], rota [i +1) )_dista) total_distance <min_distance: min_distance = total_distance best_route = rota retornar min_distance, best_route # exemplo de uso cidades = [(0, 0), (1, 5), (2, 3)] min_dist, best_routte = tsp_naive (cidades) (3, f "] o mínimo é o mínimo, o mínimo é o Min_Dist. {best_route} ")O problema com a abordagem ingênua é que ela tem uma complexidade de tempo de O (n!), Onde n é o número de cidades. Isso significa que, à medida que o número de cidades aumenta, o algoritmo se torna extremamente lento.
Usando o algoritmo vizinho mais próximo
O algoritmo vizinho mais próximo é um algoritmo ganancioso que fornece uma solução rápida, mas nem sempre ideal. Começa em uma cidade aleatória e depois visita repetidamente a cidade não visitada mais próxima até que todas as cidades sejam visitadas. Finalmente, ele retorna à cidade inicial.
DEF TSP_NEAREST_NEIGHBOR (CIDADES): current_city = cidades [0] unvisited = set (cidades [1:]) rota = [current_city] enquanto não visitou: mais próximo_city = min (mais visited, key = lambda city: distance_city, cidade) (rota.Append (mais próxima da cidade) rota.append (cidades [0]) # retorne à cidade inicial total_distance = 0 para i no intervalo (len (rota) - 1): total_distance += distância (rota [i], rota [i +1]) retornar total_distance, rota # exemplo de uso de cidades = [(0), (1, 5), (2, 3)] print (f "A distância mínima é {min_dist} e a melhor rota é {best_route}")O algoritmo vizinho mais próximo tem uma complexidade de tempo de O (n^2), o que é muito melhor que a abordagem ingênua para um número maior de cidades. No entanto, nem sempre fornece a solução ideal.
A abordagem de programação dinâmica
A programação dinâmica pode ser usada para resolver o TSP com mais eficiência para tamanhos de problemas menores. A idéia básica é dividir o problema em sub -problemas menores e armazenar as soluções para esses problemas sub -para evitar cálculos redundantes.
de functools import lru_cache @lru_cache (maxsize = nenhum) def tsp_dp (máscara, pos, dist_matrix): num_cities = len (dist_matrix) se máscara == (1 << num_cities) - 1: retornar dist_matrix [Pos] [0] Ans = (1 << Num_cities) - 1: retornar dist_matrix [POS] [0] << next_city)) == 0: new_mask = máscara | (1 << next_city) new_cost = dist_matrix [POS] [next_city]+tsp_dp (new_mask, next_city, dist_matrix) Ans = min (Ans, new_cost) retorna Ans # Exemplo de uso de cidades = [(0, 0), (1, 5), (2, 3)] cidade1 em cidades] min_dist = tsp_dp (1, 0, tupla (mapa (tupla, dist_matrix))) impressão (f "a distância mínima é {min_dist}")A abordagem de programação dinâmica tem uma complexidade de tempo de O (n^2 * 2^n), que é melhor que a abordagem ingênua, mas ainda não é adequada para um número muito grande de cidades.
Nossos produtos TSP
Como fornecedor de TSP, oferecemos uma variedade de produtos de alta qualidade. Por exemplo, nós temosTripolifosfato de sódio 95% STPP Alimentar Grade como agente de retenção de água. Este produto é amplamente utilizado na indústria de alimentos como agente de retenção de água, ajudando a manter a comida fresca e úmida.
Nós também temosIngrediente alimentar de fosfato de monopotássio. É um ingrediente alimentar importante que pode ser usado em várias aplicações alimentares.
E nossoMais vendido fosfato de dissódio (dsp) grau alimentar Na2hpo4 dspé um vendedor superior, conhecido por sua alta qualidade e eficácia no processamento de alimentos.
Embrulhando
A implementação de algoritmos de TSP no Python pode ser uma experiência divertida e gratificante. Esteja você usando a abordagem ingênua, o algoritmo vizinho mais próximo ou a programação dinâmica, cada método tem seus próprios prós e contras. À medida que o número de cidades aumenta, você precisará escolher o algoritmo que melhor atenda às suas necessidades em termos de complexidade do tempo e otimização da solução.
Se você estiver interessado em nossos produtos TSP ou tiver alguma dúvida sobre os algoritmos de TSP, fique à vontade para alcançar. Estamos sempre felizes em ajudar com sua TSP - necessidades relacionadas e discutir possíveis oportunidades de negócios.
Referências
- Cormen, TH, Leison, CE, Rivest, RL, & Stein, C. (2009). Introdução a algoritmos. Com prensa.
- Skiena, SS (2020). O manual de design do algoritmo. Springer.