Update app.py

app.py

@@ -8,9 +8,9 @@ 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) -> tuple:
+def held_karp_tsp_fixed_start(dist_matrix: np.ndarray, return_to_start: bool = True) -> tuple:
     """
-    Modified Held-Karp algorithm for solving TSP
+    Modified Held-Karp algorithm for solving TSP with fixed starting point (index 0)
     Returns: (minimum cost, optimal route)
     """
     if len(dist_matrix) < 2:
@@ -19,19 +19,24 @@ def held_karp_tsp(dist_matrix: np.ndarray, return_to_start: bool = True) -> tupl
     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][i] = dist_matrix[0][i]
+        dp[1 << i | 1][i] = dist_matrix[0][i]
     
+    # Process all possible subsets of cities
     for mask in range(1, 1 << n):
-        if bin(mask).count('1') <= 1:
+        if not (mask & 1):  # Skip if start city (0) is not in the subset
             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
+                continue
             for prev in range(n):
                 if not (prev_mask & (1 << prev)):
                     continue
@@ -40,14 +45,18 @@ def held_karp_tsp(dist_matrix: np.ndarray, return_to_start: bool = True) -> tupl
                     dp[mask][curr] = candidate
                     parent[mask][curr] = prev
 
+    # Find the optimal end point
     mask = (1 << n) - 1
     if return_to_start:
-        curr = min(range(n), key=lambda x: dp[mask][x] + dist_matrix[x][0])
+        # For closed loop, find best path back to start
+        curr = min(range(1, n), key=lambda x: dp[mask][x] + dist_matrix[x][0])
         final_cost = dp[mask][curr] + dist_matrix[curr][0]
     else:
-        curr = min(range(n), key=lambda x: dp[mask][x])
+        # For single trip, find best ending point
+        curr = min(range(1, n), key=lambda x: dp[mask][x])
         final_cost = dp[mask][curr]
     
+    # Reconstruct the path
     path = []
     while curr != -1:
         path.append(curr)
@@ -55,18 +64,17 @@ def held_karp_tsp(dist_matrix: np.ndarray, return_to_start: bool = True) -> tupl
         curr = parent[mask][curr]
         mask = new_mask
     
+    path.append(0)  # Add start city
     if return_to_start:
-        path.append(0)
+        path.append(0)  # Add start city again for closed loop
     path.reverse()
     
     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
-    Returns: (distance in km, encoded polyline of the route)
-    """
+    """Get route using OSRM public API"""
     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}"
@@ -110,9 +118,7 @@ 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
-    """
+    """Create distance matrix and store routes between all points"""
     valid_coordinates = [c for c in coordinates if c is not None]
     n = len(valid_coordinates)
     
@@ -149,9 +155,7 @@ 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
-    """
+    """Plot route using actual road paths from OSRM"""
     route_group = folium.FeatureGroup(name="Route")
     
     for i in range(len(route)-1):
@@ -204,6 +208,7 @@ def main():
     st.markdown("""
     Temukan rute optimal berkendara antar lokasi.
     Masukkan nama lokasi dibawah dan klik 'Optimize Route' untuk melihat hasilnya.
+    Kota 1 akan menjadi titik awal perjalanan.
     """)
 
     col1, col2 = st.columns([1, 2])
@@ -231,8 +236,9 @@ def main():
         city_coords = []
         
         for i in range(city_count):
+            label = "Kota 1 (Titik Awal)" if i == 0 else f"Kota {i+1}"
             city_name = st.text_input(
-                f"Kota {i+1}",
+                label,
                 value=st.session_state.city_inputs[i],
                 key=f"city_{i}"
             )
@@ -264,7 +270,7 @@ def main():
                     start_time = time.time()
                     
                     dist_matrix, valid_coordinates, routes_dict = create_distance_matrix_with_routes(city_coords)
-                    min_cost, optimal_route = held_karp_tsp(dist_matrix, return_to_start)
+                    min_cost, optimal_route = held_karp_tsp_fixed_start(dist_matrix, return_to_start)
                     
                     end_time = time.time()