Update app.py

app.py

@@ -19,23 +19,20 @@ def held_karp_tsp_fixed_start(dist_matrix: np.ndarray, return_to_start: bool = T
     n = len(dist_matrix)
     inf = float('inf')
     
-    # Only consider paths that start from index 0
     dp = np.full((1 << n, n), inf)
     parent = np.full((1 << n, n), -1, dtype=int)
     
-    # Initialize paths from start (index 0) to other cities
     for i in range(1, n):
         dp[1 << i | 1][i] = dist_matrix[0][i]
     
-    # Process all possible subsets of cities
     for mask in range(1, 1 << n):
-        if not (mask & 1):  # Skip if start city (0) is not in the subset
+        if not (mask & 1):
             continue
         for curr in range(n):
             if not (mask & (1 << curr)):
                 continue
             prev_mask = mask ^ (1 << curr)
-            if not prev_mask:  # Skip if no previous cities
+            if not prev_mask:
                 continue
             for prev in range(n):
                 if not (prev_mask & (1 << prev)):
@@ -45,18 +42,18 @@ def held_karp_tsp_fixed_start(dist_matrix: np.ndarray, return_to_start: bool = T
                     dp[mask][curr] = candidate
                     parent[mask][curr] = prev
 
-    # Find the optimal end point
     mask = (1 << n) - 1
     if return_to_start:
-        # For closed loop, find best path back to start
-        curr = min(range(1, n), key=lambda x: dp[mask][x] + dist_matrix[x][0])
+        curr = min(range(1, n), key=lambda x: dp[mask][x] + dist_matrix[x][0] if dp[mask][x] != inf else inf)
+        if dp[mask][curr] == inf:
+            return inf, []
         final_cost = dp[mask][curr] + dist_matrix[curr][0]
     else:
-        # For single trip, find best ending point
-        curr = min(range(1, n), key=lambda x: dp[mask][x])
+        curr = min(range(1, n), key=lambda x: dp[mask][x] if dp[mask][x] != inf else inf)
+        if dp[mask][curr] == inf:
+            return inf, []
         final_cost = dp[mask][curr]
     
-    # Reconstruct the path
     path = []
     while curr != -1:
         path.append(curr)
@@ -64,14 +61,14 @@ def held_karp_tsp_fixed_start(dist_matrix: np.ndarray, return_to_start: bool = T
         curr = parent[mask][curr]
         mask = new_mask
     
-    path.append(0)  # Add start city
-    if return_to_start:
-        path.append(0)  # Add start city again for closed loop
+    path.append(0)
     path.reverse()
     
+    if return_to_start:
+        path.append(0)
+    
     return final_cost, path
 
-# Keep other helper functions unchanged
 @st.cache_data
 def get_route_osrm(start_coords: tuple, end_coords: tuple) -> tuple:
     """Get route using OSRM public API"""
@@ -165,30 +162,38 @@ def plot_route_with_roads(map_obj: folium.Map, coordinates: list, route: list,
         
         if route_key in routes_dict:
             decoded_path = polyline.decode(routes_dict[route_key])
+            segment_label = (f"Return to {city_names[end_idx]}" if i == len(route)-2 and return_to_start 
+                           else f"Segment {i+1}: {city_names[start_idx]} → {city_names[end_idx]}")
+            
             folium.PolyLine(
                 decoded_path,
                 color="blue",
                 weight=3,
                 opacity=0.8,
-                tooltip=f"Segment {i+1}: {city_names[start_idx]} → {city_names[end_idx]}"
+                tooltip=segment_label
             ).add_to(route_group)
     
     for i, point_idx in enumerate(route):
-        if return_to_start:
-            icon_color = "green" if i == 0 or i == len(route)-1 else "blue"
-        else:
-            icon_color = "green" if i == 0 else "red" if i == len(route)-1 else "blue"
+        if return_to_start and i == len(route) - 1:
+            continue
+            
+        is_start = i == 0
+        is_end = (i == len(route) - 1) if not return_to_start else (i == len(route) - 2)
+        
+        icon_color = "green" if is_start else "red" if is_end else "blue"
+        stop_number = "Start" if is_start else "End" if is_end else f"Stop {i}"
             
         popup_text = f"""
         <div style='font-size: 12px'>
             <b>City:</b> {city_names[point_idx]}<br>
-            <b>Stop:</b> {i + 1} of {len(route)}
+            <b>Stop:</b> {stop_number}
         </div>
         """
+        
         folium.Marker(
             location=coordinates[point_idx],
             popup=folium.Popup(popup_text, max_width=200),
-            tooltip=f'Stop {i + 1}: {city_names[point_idx]}',
+            tooltip=f'{stop_number}: {city_names[point_idx]}',
             icon=folium.Icon(color=icon_color, icon='info-sign')
         ).add_to(route_group)
     
@@ -206,8 +211,7 @@ def main():
     
     st.title("🌍 Route Optimizer")
     st.markdown("""
-    Temukan rute optimal berkendara antar lokasi.
-    Masukkan nama lokasi dibawah dan klik 'Optimize Route' untuk melihat hasilnya.
+    Temukan rute optimal berkendara antar lokasi. Masukkan nama lokasi dibawah dan klik 'Optimize Route' untuk melihat hasilnya.
     Kota 1 akan menjadi titik awal perjalanan.
     """)
 
@@ -280,7 +284,11 @@ def main():
                         st.success(f"✅ Rute dihitung dalam {end_time - start_time:.2f} detik")
                         st.write(f"🛣️ Total jarak berkendara: {min_cost:.2f} km")
                         st.write("📍 Rute optimal:")
-                        route_text = " → ".join([city_names[i] for i in optimal_route])
+                        
+                        route_cities = [city_names[i] for i in optimal_route]
+                        if return_to_start:
+                            route_cities = route_cities[:-1]
+                        route_text = " → ".join(route_cities)
                         st.code(route_text)
                         
                         map_obj = plot_route_with_roads(map_obj, valid_coordinates, optimal_route,