Update app.py

app.py

@@ -8,24 +8,17 @@ import time
 from functools import lru_cache
 from concurrent.futures import ThreadPoolExecutor
 
-def held_karp_tsp(dist_matrix: np.ndarray, return_to_start: bool = True, start_idx: int = 0, end_idx: int = None) -> tuple:
+def held_karp_tsp(dist_matrix: np.ndarray, return_to_start: bool = True) -> tuple:
+    """
+    Modified Held-Karp algorithm for solving TSP
+    Returns: (minimum cost, optimal route)
+    """
     if len(dist_matrix) < 2:
         return 0, []
 
     n = len(dist_matrix)
     inf = float('inf')
     
-    if start_idx != 0:
-        new_matrix = dist_matrix.copy()
-        new_matrix[[0, start_idx]] = new_matrix[[start_idx, 0]]
-        new_matrix[:, [0, start_idx]] = new_matrix[:, [start_idx, 0]]
-        dist_matrix = new_matrix
-        
-        if end_idx == 0:
-            end_idx = start_idx
-        elif end_idx == start_idx:
-            end_idx = 0
-    
     dp = np.full((1 << n, n), inf)
     parent = np.full((1 << n, n), -1, dtype=int)
     
@@ -52,12 +45,8 @@ def held_karp_tsp(dist_matrix: np.ndarray, return_to_start: bool = True, start_i
         curr = min(range(n), key=lambda x: dp[mask][x] + dist_matrix[x][0])
         final_cost = dp[mask][curr] + dist_matrix[curr][0]
     else:
-        if end_idx is not None:
-            curr = end_idx if end_idx < start_idx else (end_idx - 1)
-            final_cost = dp[mask][curr]
-        else:
-            curr = min(range(n), key=lambda x: dp[mask][x])
-            final_cost = dp[mask][curr]
+        curr = min(range(n), key=lambda x: dp[mask][x])
+        final_cost = dp[mask][curr]
     
     path = []
     while curr != -1:
@@ -70,13 +59,14 @@ def held_karp_tsp(dist_matrix: np.ndarray, return_to_start: bool = True, start_i
         path.append(0)
     path.reverse()
     
-    if start_idx != 0:
-        path = [(i if i != 0 else start_idx) if i != start_idx else 0 for i in path]
-    
     return final_cost, path
 
 @st.cache_data
 def get_route_osrm(start_coords: tuple, end_coords: tuple) -> tuple:
+    """
+    Get route using OSRM public API
+    Returns: (distance in km, encoded polyline of the route)
+    """
     try:
         coords = f"{start_coords[1]},{start_coords[0]};{end_coords[1]},{end_coords[0]}"
         url = f"http://router.project-osrm.org/route/v1/driving/{coords}"
@@ -108,6 +98,7 @@ def get_route_osrm(start_coords: tuple, end_coords: tuple) -> tuple:
 
 @st.cache_data
 def cached_geocoding(city_name: str) -> tuple:
+    """Cache geocoding results"""
     try:
         geolocator = Nominatim(user_agent="tsp_app")
         location = geolocator.geocode(city_name, timeout=10)
@@ -119,6 +110,9 @@ def cached_geocoding(city_name: str) -> tuple:
         return None
 
 def create_distance_matrix_with_routes(coordinates: list) -> tuple:
+    """
+    Create distance matrix and store routes between all points using OSRM
+    """
     valid_coordinates = [c for c in coordinates if c is not None]
     n = len(valid_coordinates)
     
@@ -155,6 +149,9 @@ def create_distance_matrix_with_routes(coordinates: list) -> tuple:
 
 def plot_route_with_roads(map_obj: folium.Map, coordinates: list, route: list, 
                          city_names: list, routes_dict: dict, return_to_start: bool) -> folium.Map:
+    """
+    Plot route using actual road paths from OSRM
+    """
     route_group = folium.FeatureGroup(name="Route")
     
     for i in range(len(route)-1):
@@ -216,7 +213,7 @@ def main():
         
         trip_type = st.radio(
             "Tipe Perjalanan",
-            ["Single Trip (Titik awal ke titik akhir)", "Closed Loop (Kembali ke titik awal)"],
+            ["Closed Loop (Kembali ke titik awal)", "Single Trip (Tidak kembali ke titik awal)"],
             help="Pilih apakah Anda ingin kembali ke lokasi awal atau tidak"
         )
         return_to_start = trip_type.startswith("Closed Loop")
@@ -234,9 +231,8 @@ def main():
         city_coords = []
         
         for i in range(city_count):
-            label = "Kota Asal" if i == 0 else "Kota Tujuan" if i == city_count-1 else f"Kota {i+1}"
             city_name = st.text_input(
-                label,
+                f"Kota {i+1}",
                 value=st.session_state.city_inputs[i],
                 key=f"city_{i}"
             )
@@ -252,7 +248,7 @@ def main():
 
     with col2:
         if not city_coords:
-            map_center = [-2.548926, 118.014863]
+            map_center = [-2.548926, 118.014863]  # Center of Indonesia
             zoom_start = 5
         else:
             map_center = city_coords[0]
@@ -268,16 +264,7 @@ def main():
                     start_time = time.time()
                     
                     dist_matrix, valid_coordinates, routes_dict = create_distance_matrix_with_routes(city_coords)
-                    
-                    start_idx = 0
-                    end_idx = len(valid_coordinates) - 1 if not return_to_start else None
-                    
-                    min_cost, optimal_route = held_karp_tsp(
-                        dist_matrix, 
-                        return_to_start=return_to_start,
-                        start_idx=start_idx,
-                        end_idx=end_idx
-                    )
+                    min_cost, optimal_route = held_karp_tsp(dist_matrix, return_to_start)
                     
                     end_time = time.time()