427 KiB
427 KiB
Projet algorithme¶
Contexte du projet:¶
L'ADEME a lancé un appel à manifestation d'intérêt pour développer des solutions de mobilité adaptées à différents territoires. CesiCDP, en collaboration avec des partenaires, s'est spécialisé dans la Mobilité Multimodale Intelligente. Dans le cadre de cet appel, l'équipe de CesiCDP travaille sur la gestion de tournées de livraison pour minimiser les trajets et optimiser l'efficacité. L'objectif est d'obtenir de nouveaux marchés et des financements pour poursuivre le développement de l'entreprise. Des contraintes supplémentaires seront ajoutées pour rendre le problème plus réaliste et intéressant pour l'ADEME.
Notre but est de réaliser un algorithme permettant de passer par tous les points de livraisons avec un temps optimisé.
Contraintes choisies :¶
Les contraintes que nous avons choisi sont les suivantes:
- Avoir plusieurs camions disponible simultanément pour effectuer les livraisons.
- Fenêtre de temps de livraison pour chaque object
Formulation du problème¶
Soit un graphe $G=(V,E)$, où $V$ est l'ensemble des villes (ou points de livraison) et $E$ est l'ensemble des routes entre les villes. Chaque ville $v∈V$ a une fenêtre de temps de livraison $[a_v,b_v]$, où $a_v$ est le début de la fenêtre et $b_v$ est la fin de la fenêtre. Il y a $k$ camions disponibles pour effectuer les livraisons.
Le problème consiste à trouver une tournée pour chaque camion, de manière à ce que toutes les livraisons soient effectuées dans leurs fenêtres de temps respectives et que la date de retour du dernier camion à la base soit minimisée.
Le problème que nous avons avec les contraintes ci-dessus est le problème du VRPTW (Vehicule Routing Problem avec la contrainte supplémentaire de fenêtres d'ouverture).
Contraintes du problème¶
Liste des contraintes du problème:
- Tous les clients doivent être déservis
- Un client ne peut être servi que par un et un seul véhicule.
- En quittant un client, un véhicule peut aller que vers un seul autre client.
- Un véhicule ne peut servir un client que s'il a assez de capacité pour servir le client.
On va donc affecter chaque client à une tournée effectué par un seul véhicule.
Modélisation mathématique¶
Ensemble et paramètres:¶
$V=\{0,1,2,...,n\}$ : l'ensemble des villes, où 0 est la base (ou le dépôt) et $1,2,...,n$ sont les villes de livraison.
$K=\{1,2,...,k\}$ : l'ensemble des camions.
$d_{ij}$ : la distance (ou le temps de trajet) de la ville ii à la ville $j$.
$[a_i,b_i]$ : la fenêtre de temps de livraison pour la ville $i$.
$M$ : une grande constante.
Variables de décision:¶
$x_{ijk}$ : variable binaire qui vaut 1 si le camion $k$ se déplace de la ville $i$ à la ville $j$, et 0 sinon.
$t_{ik}$ : le moment où le camion $k$ arrive à la ville $i$.
Fonction objective:¶
Minimiser $Z=max_{k∈K}t_{0k}$
Contraintes:¶
Chaque ville est visitée une fois et une seule fois : $$\sum_{k∈K} \sum_{j∈V} x_{ijk} = 1, ∀i \in V∖ \{0\}$$
Si un camion se déplace de la ville ii à la ville $j$, alors le moment d'arrivée à la ville $j$ doit être plus grand que le moment d'arrivée à la ville $i$ plus le temps de trajet : $$t_{ik}+d_{ij} \leq t_{jk}+M(1−x_{ijk}),∀i,j \in V,i \ne j,∀k \in K$$
Les fenêtres de temps de livraison doivent être respectées : $$a_i \leq t_{ik} \leq b_i, ∀i \in V∖ \{0 \},∀k \in K$$
Les contraintes de flux pour garantir que si un camion entre dans une ville, il doit également en sortir : $$i \in V,i \ne j∑xijk=i∈V,i \ne j∑xjik=yjk,∀j∈V,∀k∈K$$
Nous allons représenter notre problème par un graphe
$G=(V,E)$
$V$ représente les sommets du graphe qui correspondent aux clients
$E$ représente les arcs entre deux clients $i,j \in V$
On a un ensemble $C=\{1,2,...,n_c\}$ de clients qui doivent obtenir leur livraison qui provient du dépot.
L'ensemble des emplacements des clients est défini comme : $V = C \cup \{0, n_c+1\} $
$0$ et $n_c+1$ représente le dépot, puisqu'on doit revenir au point de départ le dépots est le dernier client plus un.
On a un ensemble $V=\{1,2,...,n_v\}$ de véhicule disponible et chaque véhicule possède une capacité $Q$.
Variables de décisions:¶
Variables de décision:
- Un ensemble de k véhicule
Initialisation de la matrice¶
In [17]:
import random import networkx as nx import matplotlib.pyplot as plt import numpy as np def generate_graph(num_nodes): G = nx.Graph() G.add_nodes_from(range(num_nodes + 1)) for node in G.nodes(): connected_nodes = sorted(set(G.nodes()) - {node}) if len(connected_nodes) < 2: continue distance1 = random.randint(1, 10) distance2 = random.randint(1, 10) random_nodes = random.sample(connected_nodes, 2) G.add_edges_from([(node, random_nodes[0], {'distance': distance1}), (node, random_nodes[1], {'distance': distance2})]) while not nx.is_connected(G): node1, node2 = random.sample(G.nodes(), 2) if not G.has_edge(node1, node2): distance = random.randint(1, 10) G.add_edge(node1, node2, distance=distance) return G graph = generate_graph(10) A = nx.adjacency_matrix(graph).todense() def generate_distance_matrix(graph): distance_matrix = dict(nx.floyd_warshall(graph)) num_nodes = graph.number_of_nodes() distance_array = np.full((num_nodes, num_nodes), np.inf) for i, row in distance_matrix.items(): for j, distance in row.items(): if i != j: distance_array[i][j] = distance return distance_array # Générer la matrice de distances distance_matrix = generate_distance_matrix(graph) # Afficher la matrice de distances print(distance_matrix) print(A) # Dessiner le graphe nx.draw(graph, with_labels=True) plt.show()
[[inf 1. 1. 2. 1. 1. 2. 1. 2. 2. 2.] [ 1. inf 2. 1. 2. 2. 3. 2. 3. 1. 3.] [ 1. 2. inf 3. 2. 2. 1. 2. 1. 1. 2.] [ 2. 1. 3. inf 1. 3. 4. 2. 3. 2. 4.] [ 1. 2. 2. 1. inf 2. 3. 1. 2. 1. 3.] [ 1. 2. 2. 3. 2. inf 2. 1. 1. 3. 1.] [ 2. 3. 1. 4. 3. 2. inf 3. 2. 2. 1.] [ 1. 2. 2. 2. 1. 1. 3. inf 1. 2. 2.] [ 2. 3. 1. 3. 2. 1. 2. 1. inf 2. 1.] [ 2. 1. 1. 2. 1. 3. 2. 2. 2. inf 3.] [ 2. 3. 2. 4. 3. 1. 1. 2. 1. 3. inf]] [[0 1 1 0 1 1 0 1 0 0 0] [1 0 0 1 0 0 0 0 0 1 0] [1 0 0 0 0 0 1 0 1 1 0] [0 1 0 0 1 0 0 0 0 0 0] [1 0 0 1 0 0 0 1 0 1 0] [1 0 0 0 0 0 0 1 1 0 1] [0 0 1 0 0 0 0 0 0 0 1] [1 0 0 0 1 1 0 0 1 0 0] [0 0 1 0 0 1 0 1 0 0 1] [0 1 1 0 1 0 0 0 0 0 0] [0 0 0 0 0 1 1 0 1 0 0]]
Définition des données du problème VRPTW
In [18]:
#k Nombre de camion disponible num_truck = 4 # 2. Attribuer les fenêtres de temps aux clients def assign_time_windows(graph): # Créer un dictionnaire pour stocker les fenêtres de temps des clients time_windows = {} # Définir la fenêtre de temps pour le dépôt central (nœud 0) time_windows[0] = (0, float('inf')) # Assigner une fenêtre de temps à chaque client for node in graph.nodes(): if node !=0 and node != graph.number_of_nodes() : # Générer une fenêtre de temps aléatoire pour chaque client start_time = random.randint(0, 100) end_time = start_time + random.randint(10, 50) time_windows[node] = (start_time, end_time) return time_windows # Attribuer les fenêtres de temps aux clients time_windows = assign_time_windows(graph) print(max(graph.nodes())) # Afficher les fenêtres de temps assignées for node, window in time_windows.items(): print("Client", node, ":", window) #paramètres ACO print(graph.nodes()) print(graph.edges())
10 Client 0 : (0, inf) Client 1 : (35, 66) Client 2 : (48, 88) Client 3 : (87, 137) Client 4 : (45, 67) Client 5 : (36, 69) Client 6 : (57, 97) Client 7 : (24, 38) Client 8 : (21, 50) Client 9 : (50, 83) Client 10 : (100, 119) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] [(0, 7), (0, 1), (0, 2), (0, 4), (0, 5), (1, 9), (1, 3), (2, 9), (2, 6), (2, 8), (3, 4), (4, 7), (4, 9), (5, 7), (5, 8), (5, 10), (6, 10), (7, 8), (8, 10)]
Définition de l'algorithme des fourmis (marche pas encore)¶
In [19]:
# Nombre de fourmis num_ants = 10 num_iterations = 100 alpha = 1 #importance de la phéromone beta = 2 #importance de la distance evaporation_rate = 0.5 deposit_amount = 1 pheromones = np.ones((max(graph.nodes()), max(graph.nodes()))) #matrice de phéromones def evaporate_pheromones(pheromones, evaporation_rate): pheromones *= (1 - evaporation_rate) def deposit_pheromones(pheromones, path, path_lengh, deposit_amount): for i in range(len(path) - 1): pheromones[path[i], path[i+1]] += deposit_amount / path_length pheromones[path[-1], 0] += deposit_amount / path_length def check_time_window(neighbor_node, visited_nodes, time_windows, truck): if neighbor_node ==0: return True current_time = truck['current_time'] start_time, end_time = time_windows[neighbor_node -1] if start_time <= current_time <= end_time: return True else: return False def calculate_probabilities(graph, pheromones, current_node, visited_nodes, remaining_nodes, alpha, beta, time_windows, truck): probabilities = [] total_probability = 0 for neighbor_node in remaining_nodes: if graph.has_edge(current_node, neighbor_node) and check_time_window(neighbor_node, visited_nodes, time_windows, truck): distance = graph[current_node][neighbor_node]['distance'] if not np.isinf(distance): pheromone = pheromones[current_node][neighbor_node] heuristic = 1 / distance probability = (pheromone ** alpha) * (heuristic ** beta) probabilities.append((neighbor_node, probability)) total_probability += probability # Normalisation des probabilités probabilities = [(neighbor_node, probability / total_probability) for neighbor_node, probability in probabilities] return probabilities def select_next_node(probabilities, remaining_nodes): random_number = random.random() cumulative_probability = 0 for neighbor_node, probability in probabilities: cumulative_probability += probability if random_number <= cumulative_probability: return neighbor_node if probabilities: return random.choice([neighbor_node for neighbor_node, _ in probabilities]) else: return random.choice(list(remaining_nodes)) def generate_solution(graph, pheromones, alpha, beta, time_windows, num_truck): num_nodes = graph.number_of_nodes() num_vehicles = min(num_nodes - 1, num_truck) # Nombre de camions à utiliser solution = [[] for _ in range(num_vehicles)] # Liste des chemins pour chaque camion for truck in range(num_vehicles): current_node = 0 # Dépôt central comme point de départ pour chaque camion visited_nodes = set([current_node]) # Ensemble des nœuds visités par le camion remaining_nodes = set(graph.nodes()) - visited_nodes # Ensemble des nœuds restants start_time = 0 current_truck = {'current_time': start_time} while remaining_nodes: probabilities = calculate_probabilities(graph, pheromones, current_node, visited_nodes, remaining_nodes, alpha, beta, time_windows, current_truck) next_node = select_next_node(probabilities, remaining_nodes) edge_data = graph.get_edge_data(current_node, next_node) if edge_data is not None: distance = edge_data['distance'] start_time = current_truck['current_time'] + distance current_truck['current_time'] = start_time solution[truck].append((current_node, next_node)) visited_nodes.add(next_node) remaining_nodes.remove(next_node) current_node = next_node # Ajouter le retour au dépôt central à la fin du trajet du camion solution[truck].append((current_node, 0)) solution_length = calculate_solution_length(graph, solution) return solution, solution_length def calculate_solution_length(graph, solution): length = 0 for truck_path in solution: for i in range(len(truck_path) - 1): current_node, next_node = truck_path[i] distance = graph[current_node][next_node]['distance'] if not np.isinf(distance): length += distance return length # Initialiser la meilleure solution trouvée best_solution = None best_solution_length = float('inf') for iteration in range(num_iterations): for ant in range(num_ants): solution , solution_length = generate_solution(graph, pheromones, alpha, beta, time_windows, num_truck) deposit_pheromones(pheromones, solution, solution_length, deposit_amount) if solution_length < best_solution_length: best_solution = solution best_solution_length = solution_length evaporate_pheromones(pheromones, evaporation_rate) print("Meilleure solution trouvée:", best_solution) print("Longueur de la meilleure solution:", best_solution_length)
--------------------------------------------------------------------------- KeyboardInterrupt Traceback (most recent call last) Cell In[19], line 136 134 for iteration in range(num_iterations): 135 for ant in range(num_ants): --> 136 solution , solution_length = generate_solution(graph, pheromones, alpha, beta, time_windows, num_truck) 138 deposit_pheromones(pheromones, solution, solution_length, deposit_amount) 140 if solution_length < best_solution_length: Cell In[19], line 92, in generate_solution(graph, pheromones, alpha, beta, time_windows, num_truck) 89 while remaining_nodes: 90 probabilities = calculate_probabilities(graph, pheromones, current_node, visited_nodes, remaining_nodes, alpha, beta, time_windows, current_truck) ---> 92 next_node = select_next_node(probabilities, remaining_nodes) 94 edge_data = graph.get_edge_data(current_node, next_node) 95 if edge_data is not None: Cell In[19], line 67, in select_next_node(probabilities, remaining_nodes) 63 if random_number <= cumulative_probability: 64 return neighbor_node ---> 67 if probabilities: 68 return random.choice([neighbor_node for neighbor_node, _ in probabilities]) 69 else: KeyboardInterrupt:
Test 2 fourmis¶
In [201]:
import random import numpy as np import networkx as nx import matplotlib.pyplot as plt def generate_graph(num_nodes): G = nx.Graph() G.add_nodes_from(range(num_nodes + 1)) for node in G.nodes(): connected_nodes = sorted(set(G.nodes()) - {node}) if len(connected_nodes) < 2: continue distance1 = random.randint(1, 10) distance2 = random.randint(1, 10) random_nodes = random.sample(connected_nodes, 2) G.add_edges_from([(node, random_nodes[0], {'distance': distance1}), (node, random_nodes[1], {'distance': distance2})]) while not nx.is_connected(G): node1, node2 = random.sample(G.nodes(), 2) if not G.has_edge(node1, node2): distance = random.randint(1, 10) G.add_edge(node1, node2, distance=distance) # Assigner des positions aléatoires aux nœuds pos = {node: (random.uniform(0, 10), random.uniform(0, 10)) for node in G.nodes()} nx.set_node_attributes(G, pos, 'pos') return G graph = generate_graph(49) A = nx.adjacency_matrix(graph).todense() def generate_distance_matrix(graph): distance_matrix = dict(nx.floyd_warshall(graph)) num_nodes = graph.number_of_nodes() distance_array = np.zeros((num_nodes, num_nodes)) for i, row in distance_matrix.items(): for j, distance in row.items(): distance_array[i][j] = distance return distance_array # Générer la matrice de distances distance_matrix = generate_distance_matrix(graph) # Afficher la matrice de distances print(distance_matrix) print(A) pos = nx.get_node_attributes(graph, 'pos') # Dessiner le graphe nx.draw(graph, with_labels=True) plt.show()
[[0. 4. 2. ... 3. 2. 3.] [4. 0. 3. ... 3. 3. 3.] [2. 3. 0. ... 1. 2. 4.] ... [3. 3. 1. ... 0. 3. 3.] [2. 3. 2. ... 3. 0. 2.] [3. 3. 4. ... 3. 2. 0.]] [[0 0 0 ... 0 0 0] [0 0 0 ... 0 0 0] [0 0 0 ... 1 0 0] ... [0 0 1 ... 0 0 0] [0 0 0 ... 0 0 0] [0 0 0 ... 0 0 0]]
In [172]:
import time #Nombre de camion num_trucks = 2 # Fonction d'évaluation de la qualité d'une solution (ici, la distance totale) def evaluate_solution(solution, distances): total_distance = 0 num_nodes = len(solution) for i in range(num_nodes - 1): current_node = solution[i] next_node = solution[i + 1] total_distance += distances[current_node][next_node] # Ajouter la distance de retour au dépôt total_distance += distances[solution[-1]][solution[0]] return total_distance # Algorithme ACO def ant_colony_optimization(distances, num_ants, num_iterations, evaporation_rate, alpha, beta): num_nodes = len(distances) pheromone = np.ones((num_nodes, num_nodes)) # Matrice de phéromones initiale best_solution = None best_distance = float('inf') start_time = time.time() for iteration in range(num_iterations): # Construction de solutions par les fourmis solutions = [] for ant in range(num_ants): visited = set() current_node = random.randint(0, num_nodes - 1) visited.add(current_node) solution = [current_node] while len(visited) < num_nodes: next_node = None probabilities = [] # Calcul des probabilités de choisir chaque prochain nœud for node in range(num_nodes): if node not in visited: pheromone_value = pheromone[current_node][node] distance_value = distances[current_node][node] probability = (pheromone_value ** alpha) * ((1 / distance_value) ** beta) probabilities.append((node, probability)) total_probability = sum(prob for _, prob in probabilities) probabilities = [(node, prob / total_probability) for node, prob in probabilities] # Choix du prochain nœud basé sur les probabilités roulette_wheel = random.random() probability_sum = 0 for node, probability in probabilities: probability_sum += probability if probability_sum >= roulette_wheel: next_node = node break visited.add(next_node) solution.append(next_node) current_node = next_node # Ajouter le retour au dépôt central à la fin du trajet solution.append(0) solutions.append(solution) # Évaluation des solutions et mise à jour de la meilleure solution for solution in solutions: distance = evaluate_solution(solution, distances) if distance < best_distance: best_solution = solution best_distance = distance # Mise à jour des phéromones pheromone *= evaporation_rate # Évaporation des phéromones existantes for solution in solutions: delta_pheromone = 1 / evaluate_solution(solution, distances) for i in range(num_nodes - 1): node1 = solution[i] node2 = solution[i + 1] pheromone[node1][node2] += delta_pheromone pheromone[node2][node1] += delta_pheromone return best_solution, best_distance num_ants = 10 num_iterations = 100 evaporation_rate = 0.5 alpha = 1 beta = 1 best_solution, best_distance = ant_colony_optimization(distance_matrix, num_ants, num_iterations, evaporation_rate, alpha, beta) print("Meilleure solution :", best_solution) print("Distance totale :", best_distance)
Meilleure solution : [0, 43, 28, 39, 20, 12, 13, 11, 21, 24, 3, 46, 22, 14, 19, 5, 7, 18, 36, 15, 8, 38, 29, 30, 31, 44, 6, 41, 26, 34, 9, 1, 35, 33, 40, 2, 45, 4, 23, 49, 50, 37, 27, 25, 42, 47, 48, 16, 17, 10, 32, 0] Distance totale : 62.0
Calcul de l'évolution du temps en fonction du nombre de villes¶
In [96]:
x_values = [graph.nodes[x]['pos'][0] for x in best_solution] y_values = [graph.nodes[x]['pos'][1] for x in best_solution] # Création de la figure et des axes fig, ax = plt.subplots() ax.set_aspect('equal') ax.set_xlabel('Coordonnée X') ax.set_ylabel('Coordonnée Y') ax.set_title("Tracé du trajet emprunté par les fourmis") # Tracer le graphe sans les arêtes nx.draw_networkx_nodes(graph, pos=nx.get_node_attributes(graph, 'pos'), ax=ax) nx.draw_networkx_labels(graph, pos=nx.get_node_attributes(graph, 'pos'), ax=ax) # Tracer uniquement le trajet emprunté par les fourmis ax.plot(x_values, y_values, linestyle='-', marker='o') # Tracer une ligne du dernier nœud au premier nœud pour fermer la boucle ax.plot([x_values[-1], x_values[0]], [y_values[-1], y_values[0]], linestyle='-', color='r') # Afficher le graphique plt.show()
Avec un nombre de camion disponible¶
In [202]:
import concurrent.futures num_trucks = 3 # Nombre de camions disponibles # Fonction d'évaluation de la qualité d'une solution (ici, la distance totale) def evaluate_solution(solution, distances): total_distance = 0 num_nodes = len(solution) for i in range(num_nodes - 1): current_node = solution[i] next_node = solution[i + 1] total_distance += distances[current_node][next_node] #if solution[-1] == 0 and len(solution) < num_nodes: #return float('inf') # Ajouter la distance de retour au dépôt total_distance += distances[solution[-1]][solution[0]] return total_distance def ant_colony_optimization(distances, num_ants, num_iterations, evaporation_rate, alpha, beta, num_trucks): num_nodes = len(distances) pheromone = np.ones((num_nodes, num_nodes)) # Matrice de phéromones initiale best_solution = None best_distance = float('inf') start_time = time.time() for iteration in range(num_iterations): # Construction de solutions par les fourmis solutions = [] for ant in range(num_ants): visited = set() current_node = random.randint(0, num_nodes - 1) visited.add(current_node) solution = [current_node] while len(visited) < num_nodes: next_node = None probabilities = [] # Calcul des probabilités de choisir chaque prochain nœud for node in range(num_nodes): if node not in visited and (node !=0 or len(visited) == num_nodes - 1): pheromone_value = pheromone[current_node][node] distance_value = distances[current_node][node] probability = (pheromone_value ** alpha) * ((1 / distance_value) ** beta) probabilities.append((node, probability)) total_probability = sum(prob for _, prob in probabilities) probabilities = [(node, prob / total_probability) for node, prob in probabilities] roulette_wheel = random.random() probability_sum = 0 for node, probability in probabilities: probability_sum += probability if probability_sum >= roulette_wheel: next_node = node break visited.add(next_node) solution.append(next_node) current_node = next_node # Ajouter le retour au dépôt central à la fin du trajet solution.append(0) solutions.append(solution) # Évaluation des solutions et mise à jour de la meilleure solution for solution in solutions: distance = evaluate_solution(solution, distances) if distance < best_distance: best_solution = solution best_distance = distance # Mise à jour des phéromones pheromone *= evaporation_rate # Évaporation des phéromones existantes for solution in solutions: delta_pheromone = 1 / evaluate_solution(solution, distances) for i in range(num_nodes - 1): node1 = solution[i] node2 = solution[i + 1] pheromone[node1][node2] += delta_pheromone pheromone[node2][node1] += delta_pheromone # Séparer la meilleure solution en trajets pour chaque camion truck_solutions = [] num_nodes_per_truck = num_nodes // num_trucks for i in range(num_trucks): start_index = i * num_nodes_per_truck end_index = start_index + num_nodes_per_truck truck_solution = best_solution[start_index:end_index] truck_solutions.append(truck_solution + [0]) return truck_solutions, best_distance def trucks_thread(i, num_nodes_per_truck, best_solution, truck_solutions): start_index = i * num_nodes_per_truck end_index = start_index + num_nodes_per_truck truck_solution = best_solution[start_index:end_index] truck_solutions.append(truck_solution) return truck_solutions num_ants = 10 num_iterations = 100 evaporation_rate = 0.5 alpha = 1 beta = 1 best_truck_solutions, best_distance = ant_colony_optimization(distance_matrix, num_ants, num_iterations, evaporation_rate, alpha, beta, num_trucks) print("Meilleure solution :", best_truck_solutions) print("Distance totale :", best_distance)
Meilleure solution : [[48, 16, 36, 11, 49, 42, 37, 30, 38, 29, 46, 18, 15, 27, 3, 39, 0], [2, 47, 35, 31, 13, 12, 14, 23, 21, 24, 28, 9, 33, 6, 10, 4, 0], [45, 20, 22, 26, 44, 1, 7, 32, 17, 19, 25, 41, 5, 43, 40, 34, 0]] Distance totale : 59.0
In [203]:
# Créer une liste de couleurs pour chaque véhicule colors = ['red', 'blue', 'green', 'orange', 'purple'] # Ajoutez plus de couleurs si nécessaire # Création de la figure et des axes fig, ax = plt.subplots() ax.set_aspect('equal') ax.set_xlabel('Coordonnée X') ax.set_ylabel('Coordonnée Y') ax.set_title("Tracé du trajet emprunté par les fourmis") # Tracer le graphe sans les arêtes nx.draw_networkx_nodes(graph, pos=nx.get_node_attributes(graph, 'pos'), ax=ax) nx.draw_networkx_labels(graph, pos=nx.get_node_attributes(graph, 'pos'), ax=ax) # Tracer chaque trajet de chaque véhicule avec une couleur différente for i, truck_solution in enumerate(best_truck_solutions): x_values = [graph.nodes[x]['pos'][0] for x in truck_solution] y_values = [graph.nodes[x]['pos'][1] for x in truck_solution] ax.plot(x_values, y_values, linestyle='-', marker='o', color=colors[i % len(colors)]) # Tracer une ligne du dernier nœud au premier nœud pour fermer la boucle ax.plot([x_values[-1], x_values[0]], [y_values[-1], y_values[0]], linestyle='-', color=colors[i % len(colors)]) # Afficher le graphique plt.show()