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) -> tuple:
+def held_karp_tsp(dist_matrix: np.ndarray, return_to_start: bool = True) -> tuple:
     """
-    Held-Karp algorithm for solving TSP
+    Modified Held-Karp algorithm for solving TSP
     Returns: (minimum cost, optimal route)
     """
     if len(dist_matrix) < 2:
@@ -19,15 +19,12 @@ def held_karp_tsp(dist_matrix: np.ndarray) -> tuple:
     n = len(dist_matrix)
     inf = float('inf')
     
-    # Use numpy arrays for better performance
     dp = np.full((1 << n, n), inf)
     parent = np.full((1 << n, n), -1, dtype=int)
     
-    # Base cases
     for i in range(1, n):
         dp[1 << i][i] = dist_matrix[0][i]
     
-    # Main DP loop
     for mask in range(1, 1 << n):
         if bin(mask).count('1') <= 1:
             continue
@@ -43,9 +40,14 @@ def held_karp_tsp(dist_matrix: np.ndarray) -> tuple:
                     dp[mask][curr] = candidate
                     parent[mask][curr] = prev
 
-    # Reconstruct path
     mask = (1 << n) - 1
-    curr = min(range(n), key=lambda x: dp[mask][x] + dist_matrix[x][0])
+    if return_to_start:
+        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]
+    
     path = []
     while curr != -1:
         path.append(curr)
@@ -53,10 +55,11 @@ def held_karp_tsp(dist_matrix: np.ndarray) -> tuple:
         curr = parent[mask][curr]
         mask = new_mask
     
-    path.append(0)
+    if return_to_start:
+        path.append(0)
     path.reverse()
     
-    return dp[(1 << n) - 1][path[-2]] + dist_matrix[path[-2]][0], path
+    return final_cost, path
 
 @st.cache_data
 def get_route_osrm(start_coords: tuple, end_coords: tuple) -> tuple:
@@ -65,10 +68,7 @@ def get_route_osrm(start_coords: tuple, end_coords: tuple) -> tuple:
     Returns: (distance in km, encoded polyline of the route)
     """
     try:
-        # Format coordinates for OSRM (lon,lat format)
         coords = f"{start_coords[1]},{start_coords[0]};{end_coords[1]},{end_coords[0]}"
-        
-        # OSRM public API endpoint
         url = f"http://router.project-osrm.org/route/v1/driving/{coords}"
         params = {
             "overview": "full",
@@ -82,8 +82,8 @@ def get_route_osrm(start_coords: tuple, end_coords: tuple) -> tuple:
             data = response.json()
             if data["code"] == "Ok" and len(data["routes"]) > 0:
                 route = data["routes"][0]
-                distance = route["distance"] / 1000  # Convert to km
-                geometry = route["geometry"]  # Already encoded polyline
+                distance = route["distance"] / 1000
+                geometry = route["geometry"]
                 return distance, geometry
             else:
                 st.warning("No route found")
@@ -120,18 +120,17 @@ def create_distance_matrix_with_routes(coordinates: list) -> tuple:
         return np.array([]), valid_coordinates, {}
         
     dist_matrix = np.zeros((n, n))
-    routes_dict = {}  # Store encoded polylines for routes
+    routes_dict = {}
     
     def calculate_route(i, j):
         if i != j:
-            # Add delay to avoid hitting rate limits
-            time.sleep(0.1)  
+            time.sleep(0.1)
             distance, route = get_route_osrm(valid_coordinates[i], valid_coordinates[j])
             if distance is not None:
                 return i, j, distance, route
         return i, j, 0, None
 
-    with ThreadPoolExecutor(max_workers=5) as executor:  # Limit concurrent requests
+    with ThreadPoolExecutor(max_workers=5) as executor:
         futures = []
         for i in range(n):
             for j in range(i + 1, n):
@@ -149,21 +148,18 @@ def create_distance_matrix_with_routes(coordinates: list) -> tuple:
     return dist_matrix, valid_coordinates, routes_dict
 
 def plot_route_with_roads(map_obj: folium.Map, coordinates: list, route: list, 
-                         city_names: list, routes_dict: dict) -> folium.Map:
+                         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")
     
-    # Plot road segments between consecutive points
-    total_distance = 0
     for i in range(len(route)-1):
         start_idx = route[i]
         end_idx = route[i+1]
         route_key = f"{start_idx}-{end_idx}"
         
         if route_key in routes_dict:
-            # Decode and plot the polyline
             decoded_path = polyline.decode(routes_dict[route_key])
             folium.PolyLine(
                 decoded_path,
@@ -173,9 +169,12 @@ def plot_route_with_roads(map_obj: folium.Map, coordinates: list, route: list,
                 tooltip=f"Segment {i+1}: {city_names[start_idx]} → {city_names[end_idx]}"
             ).add_to(route_group)
     
-    # Add markers with custom icons
     for i, point_idx in enumerate(route):
-        icon_color = "green" if i == 0 else "red" if i == len(route)-1 else "blue"
+        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"
+            
         popup_text = f"""
         <div style='font-size: 12px'>
             <b>City:</b> {city_names[point_idx]}<br>
@@ -191,7 +190,6 @@ def plot_route_with_roads(map_obj: folium.Map, coordinates: list, route: list,
     
     route_group.add_to(map_obj)
     
-    # Add OpenStreetMap tile layer
     folium.TileLayer(
         tiles='https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
         attr='&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors'
@@ -212,6 +210,14 @@ def main():
 
     with col1:
         st.subheader("📍 Masukkan Lokasi")
+        
+        trip_type = st.radio(
+            "Tipe Perjalanan",
+            ["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")
+        
         city_count = st.number_input("Jumlah lokasi", min_value=2, max_value=10, value=3, step=1,
                                    help="Maksimum 10 lokasi direkomendasikan karena batasan API")
         
@@ -257,29 +263,23 @@ def main():
                 with st.spinner("Menghitung rute optimal..."):
                     start_time = time.time()
                     
-                    # Get distance matrix and routes
                     dist_matrix, valid_coordinates, routes_dict = create_distance_matrix_with_routes(city_coords)
-                    
-                    # Calculate optimal route
-                    min_cost, optimal_route = held_karp_tsp(dist_matrix)
+                    min_cost, optimal_route = held_karp_tsp(dist_matrix, return_to_start)
                     
                     end_time = time.time()
                     
                     if min_cost == float('inf'):
                         st.error("❌ Tidak dapat menemukan rute yang valid")
                     else:
-                        # Display results
                         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])
                         st.code(route_text)
                         
-                        # Update map with route
                         map_obj = plot_route_with_roads(map_obj, valid_coordinates, optimal_route, 
-                                                      city_names, routes_dict)
+                                                      city_names, routes_dict, return_to_start)
 
-        # Display map
         st.components.v1.html(folium.Map._repr_html_(map_obj), height=600)
 
 if __name__ == "__main__":