Update app.py

app.py

@@ -1,14 +1,11 @@
 import streamlit as st
 import folium
 import numpy as np
-from scipy.optimize import linear_sum_assignment
-from folium import plugins
-import requests
-from datetime import datetime
-from geopy.geocoders import Nominatim
-import polyline
 from typing import List, Tuple, Dict, Optional
 import time
+from collections import deque
+import requests
+import polyline
 
 # Utility Functions
 def create_numbered_marker(number: int) -> folium.features.DivIcon:
@@ -76,8 +73,8 @@ def get_route_from_osrm(coord1: Tuple[float, float], coord2: Tuple[float, float]
         st.warning(f"Error getting route: {str(e)}")
     return None
 
-def calculate_real_distances(places: List[Tuple[str, Tuple[float, float]]]) -> Tuple[np.ndarray, Dict]:
-    """Calculate real driving distances using OSRM"""
+def calculate_distance_matrix(places: List[Tuple[str, Tuple[float, float]]]) -> Tuple[np.ndarray, Dict]:
+    """Calculate distance matrix and routing information using OSRM"""
     n = len(places)
     distances = np.zeros((n, n))
     routing_info = {}
@@ -108,17 +105,37 @@ def calculate_real_distances(places: List[Tuple[str, Tuple[float, float]]]) -> T
     
     return distances, routing_info
 
-def optimize_route(distances: np.ndarray) -> List[int]:
-    """Optimize route using modified Hungarian algorithm for TSP"""
+def dijkstra(distances: np.ndarray, start_idx: int) -> Tuple[List[int], Dict[int, float]]:
+    """Implement Dijkstra's algorithm to find the optimal route"""
     n = len(distances)
-    row_ind, col_ind = linear_sum_assignment(distances)
+    visited = [False] * n
+    distances_to = [float('inf')] * n
+    prev_node = [-1] * n
     
-    # Convert assignment to tour
-    tour = []
-    for i in range(n):
-        tour.append(col_ind[i])
+    distances_to[start_idx] = 0
+    queue = deque([start_idx])
+    
+    while queue:
+        current_node = queue.popleft()
+        visited[current_node] = True
+        
+        for neighbor in range(n):
+            if not visited[neighbor] and distances[current_node, neighbor] > 0:
+                new_distance = distances_to[current_node] + distances[current_node, neighbor]
+                if new_distance < distances_to[neighbor]:
+                    distances_to[neighbor] = new_distance
+                    prev_node[neighbor] = current_node
+                    queue.append(neighbor)
+    
+    # Reconstruct the optimal route
+    optimal_order = []
+    node = n - 1
+    while prev_node[node] != -1:
+        optimal_order.insert(0, node)
+        node = prev_node[node]
+    optimal_order.insert(0, start_idx)
     
-    return tour
+    return optimal_order, distances_to
 
 def add_markers_and_route(m: folium.Map, places: List[Tuple[str, Tuple[float, float]]], optimal_order: List[int], routing_info: Dict):
     """Add markers and route lines to the map"""
@@ -237,16 +254,16 @@ def main():
         col1, col2 = st.columns([2, 1])
         with col1:
             with st.spinner("🚗 Calculating optimal route..."):
-                # Calculate real distances
-                distances, routing_info = calculate_real_distances(places)
+                # Calculate distance matrix
+                distances, routing_info = calculate_distance_matrix(places)
                 
-                # Get optimized route order
-                optimal_order = optimize_route(distances)
+                # Get optimized route order using Dijkstra's algorithm
+                optimal_order, _ = dijkstra(distances, 0)
                 
                 # Update the route if the user changes the input
                 if st.button("Recalculate Route"):
-                    distances, routing_info = calculate_real_distances(places)
-                    optimal_order = optimize_route(distances)
+                    distances, routing_info = calculate_distance_matrix(places)
+                    optimal_order, _ = dijkstra(distances, 0)
 
                 # Create map and display
                 m = folium.Map()