Update app.py

app.py

@@ -1,15 +1,63 @@
 import streamlit as st
 import folium
 from geopy.geocoders import Nominatim
-from itertools import combinations
 import numpy as np
 import requests
 import polyline
 import time
 from functools import lru_cache
-import json
 from concurrent.futures import ThreadPoolExecutor
 
+def held_karp_tsp(dist_matrix: np.ndarray) -> tuple:
+    """
+    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')
+    
+    # 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
+        for curr in range(n):
+            if not (mask & (1 << curr)):
+                continue
+            prev_mask = mask ^ (1 << curr)
+            for prev in range(n):
+                if not (prev_mask & (1 << prev)):
+                    continue
+                candidate = dp[prev_mask][prev] + dist_matrix[prev][curr]
+                if candidate < dp[mask][curr]:
+                    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])
+    path = []
+    while curr != -1:
+        path.append(curr)
+        new_mask = mask ^ (1 << curr)
+        curr = parent[mask][curr]
+        mask = new_mask
+    
+    path.append(0)
+    path.reverse()
+    
+    return dp[(1 << n) - 1][path[-2]] + dist_matrix[path[-2]][0], path
+
 @st.cache_data
 def get_route_osrm(start_coords: tuple, end_coords: tuple) -> tuple:
     """
@@ -152,20 +200,20 @@ def plot_route_with_roads(map_obj: folium.Map, coordinates: list, route: list,
     return map_obj
 
 def main():
-    st.set_page_config(page_title="TSP Solver with OSRM", layout="wide")
+    st.set_page_config(page_title="TSP Route Optimizer", layout="wide")
     
     st.title("🌍 TSP Route Optimizer")
     st.markdown("""
-    Find the optimal driving route between multiple cities using OSRM.
-    Enter city names below and click 'Optimize Route' to see the results.
+    Temukan rute optimal berkendara antar multiple kota menggunakan algoritma TSP.
+    Masukkan nama kota dibawah dan klik 'Optimize Route' untuk melihat hasilnya.
     """)
 
     col1, col2 = st.columns([1, 2])
 
     with col1:
-        st.subheader("📍 Enter Cities")
-        city_count = st.number_input("Number of cities", min_value=2, max_value=10, value=3, step=1,
-                                   help="Maximum 10 cities recommended due to API limits")
+        st.subheader("📍 Masukkan Kota")
+        city_count = st.number_input("Jumlah kota", min_value=2, max_value=10, value=3, step=1,
+                                   help="Maksimum 10 kota direkomendasikan karena batasan API")
         
         if 'city_inputs' not in st.session_state:
             st.session_state.city_inputs = [''] * city_count
@@ -178,7 +226,7 @@ def main():
         
         for i in range(city_count):
             city_name = st.text_input(
-                f"City {i+1}",
+                f"Kota {i+1}",
                 value=st.session_state.city_inputs[i],
                 key=f"city_{i}"
             )
@@ -190,7 +238,7 @@ def main():
                     city_names.append(city_name)
                     city_coords.append(coords)
                 else:
-                    st.warning(f"⚠️ Could not find coordinates for '{city_name}'")
+                    st.warning(f"⚠️ Tidak dapat menemukan koordinat untuk '{city_name}'")
 
     with col2:
         if not city_coords:
@@ -204,27 +252,26 @@ def main():
         
         if st.button("🔄 Optimize Route", key="optimize"):
             if len(city_coords) < 2:
-                st.error("❌ Please enter at least 2 valid cities")
+                st.error("❌ Masukkan minimal 2 kota yang valid")
             else:
-                with st.spinner("Calculating optimal route..."):
+                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
-                    from held_karp_tsp import held_karp_tsp  # Menggunakan fungsi yang sudah ada
                     min_cost, optimal_route = held_karp_tsp(dist_matrix)
                     
                     end_time = time.time()
                     
                     if min_cost == float('inf'):
-                        st.error("❌ Could not find a valid route")
+                        st.error("❌ Tidak dapat menemukan rute yang valid")
                     else:
                         # Display results
-                        st.success(f"✅ Route calculated in {end_time - start_time:.2f} seconds")
-                        st.write(f"🛣️ Total driving distance: {min_cost:.2f} km")
-                        st.write("📍 Optimal route:")
+                        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)