Update app.py

app.py

@@ -8,17 +8,24 @@ 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:
-    """
-    Modified Held-Karp algorithm for solving TSP
-    Returns: (minimum cost, optimal route)
-    """
+def held_karp_tsp(dist_matrix: np.ndarray, return_to_start: bool = True, start_idx: int = 0, end_idx: int = None) -> tuple:
     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)
     
@@ -45,8 +52,12 @@ def held_karp_tsp(dist_matrix: np.ndarray, return_to_start: bool = True) -> tupl
         curr = min(range(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])
-        final_cost = dp[mask][curr]
+        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]
     
     path = []
     while curr != -1:
@@ -59,14 +70,13 @@ def held_karp_tsp(dist_matrix: np.ndarray, return_to_start: bool = True) -> tupl
         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}"
@@ -98,7 +108,6 @@ 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)
@@ -110,9 +119,6 @@ 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)
     
@@ -149,9 +155,6 @@ 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):
@@ -213,7 +216,7 @@ def main():
         
         trip_type = st.radio(
             "Tipe Perjalanan",
-            ["Closed Loop (Kembali ke titik awal)", "Single Trip (Tidak kembali ke titik awal)"],
+            ["Single Trip (Titik awal ke titik akhir)", "Closed Loop (Kembali ke titik awal)"],
             help="Pilih apakah Anda ingin kembali ke lokasi awal atau tidak"
         )
         return_to_start = trip_type.startswith("Closed Loop")
@@ -231,8 +234,9 @@ 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(
-                f"Kota {i+1}",
+                label,
                 value=st.session_state.city_inputs[i],
                 key=f"city_{i}"
             )
@@ -248,7 +252,7 @@ def main():
 
     with col2:
         if not city_coords:
-            map_center = [-2.548926, 118.014863]  # Center of Indonesia
+            map_center = [-2.548926, 118.014863]
             zoom_start = 5
         else:
             map_center = city_coords[0]
@@ -264,7 +268,16 @@ 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)
+                    
+                    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
+                    )
                     
                     end_time = time.time()