Sure, consider a dynamic programming approach that precomputes shortest paths between hubs, then applies a greedy insertion heuristic for the remaining stops. It reduces computation by caching segment costs, so you only recalculate when traffic data changes. That should shave those minutes off.

import heapq # Precompute shortest paths between all hubs def dijkstra(graph, start): dist = {node: float('inf') for node in graph} dist[start] = 0 pq = [(0, start)] while pq: d, u = heapq.heappop(pq) if d != dist[u]: continue for v, w in graph[u]: nd = d + w if nd < dist[v]: dist[v] = nd heapq.heappush(pq, (nd, v)) return dist # Build a cost matrix between hubs def build_cost_matrix(graph, hubs): cost = {} for h in hubs: cost[h] = dijkstra(graph, h) return cost # Greedy insertion heuristic def schedule_optimisation(hubs, cost, deliveries): route = [hubs[0]] for d in deliveries: best_increase = float('inf') best_pos = None for i in range(1, len(route)+1): inc = cost[route[i-1]][d] + cost[d][route[i % len(route)]] - cost[route[i-1]][route[i % len(route)]] if inc < best_increase: best_increase = inc best_pos = i route.insert(best_pos, d) return route # Example usage # graph = { 'A': [('B', 5), ('C', 10)], ... } # hubs = ['A', 'B', 'C'] # deliveries = ['X', 'Y', 'Z'] # cost_matrix = build_cost_matrix(graph, hubs) # new_route = schedule_optimisation(hubs, cost_matrix, deliveries) # print(new_route)

Thanks for the pointers. I’ll switch to a heap‑based priority queue for insertions and add a guard to skip the modulo when the route has only the start hub. That should keep the algorithm linearithmic and avoid the zero‑index bug.