Update solver.py

solver.py

@@ -14,7 +14,6 @@ import io
 # ---------------------------
 
 def make_template_dataframe():
-    """Blank template users can download/fill."""
     return pd.DataFrame({
         "id": ["A", "B", "C"],
         "x": [10, -5, 15],
@@ -41,15 +40,14 @@ def parse_uploaded_csv(file) -> pd.DataFrame:
     for col in ["x", "y", "demand", "tw_start", "tw_end", "service"]:
         df[col] = pd.to_numeric(df[col], errors="coerce")
     df = df.dropna().reset_index(drop=True)
-    returndf
-
+    return df
 
 
 def generate_random_instance(
     n_clients=15,
     n_vehicles=4,
     capacity=7,
-    spread=10,           # smaller city area
+    spread=10,           # smaller area = closer stops
     demand_min=1,
     demand_max=3,
     seed=42,
@@ -59,11 +57,11 @@ def generate_random_instance(
     ys = rng.uniform(-spread, spread, size=n_clients)
     demands = rng.integers(demand_min, demand_max + 1, size=n_clients)
 
-    # realistic and tight time windows
+    # Wider time windows (30–45 minutes)
     tw_start = rng.integers(0, 40, size=n_clients)
-    tw_end = tw_start + rng.integers(15, 25, size=n_clients)
+    tw_end = tw_start + rng.integers(30, 45, size=n_clients)
 
-    # short service time (1 minute)
+    # Service time fixed to 1 minute
     service = np.ones(n_clients, dtype=int)
 
     df = pd.DataFrame({
@@ -78,9 +76,8 @@ def generate_random_instance(
     return df
 
 
-
 # ---------------------------
-# Geometry / distance helpers
+# Geometry helpers
 # ---------------------------
 
 def euclid(a: Tuple[float, float], b: Tuple[float, float]) -> float:
@@ -92,250 +89,180 @@ def total_distance(points: List[Tuple[float, float]]) -> float:
 
 
 # ---------------------------
-# TW-aware clustering (instead of pure sweep)
+# Time-window aware clustering
 # ---------------------------
 
-def tw_aware_clusters(df: pd.DataFrame, depot: Tuple[float, float], n_vehicles: int, capacity: float) -> List[List[int]]:
-    """
-    Cluster clients considering both angle (sweep) and time window urgency.
-    Prioritize clients with tight/early time windows to reduce violations.
-    """
+def tw_aware_clusters(df: pd.DataFrame, depot: Tuple[float, float],
+                      n_vehicles: int, capacity: float) -> List[List[int]]:
     dx = df["x"].values - depot[0]
     dy = df["y"].values - depot[1]
     ang = np.arctan2(dy, dx)
-    
-    # Compute urgency score: prefer clients with earlier tw_end
-    # Normalize by distance to avoid always picking far clients
+
     distances = np.sqrt(dx**2 + dy**2)
-    tw_urgency = df["tw_end"].values / (distances + 1.0)  # lower is more urgent relative to distance
-    
-    # Sort by angle primarily, but break ties with urgency
-    # Create composite sort key
+    tw_urgency = df["tw_end"].values / (distances + 1.0)
     order = np.lexsort((tw_urgency, ang))
 
     clusters = [[] for _ in range(n_vehicles)]
     loads = [0.0] * n_vehicles
     v = 0
-    
+
     for idx in order:
         d = float(df.loc[idx, "demand"])
         if loads[v] + d > capacity and v < n_vehicles - 1:
             v += 1
         clusters[v].append(int(idx))
         loads[v] += d
-    
+
     return clusters
 
 
 # ---------------------------
-# Enhanced scheduling with time window feasibility check
+# Schedule computation
 # ---------------------------
 
-def compute_schedule_for_route(
-    route_idxs: List[int],
-    depot: Tuple[float, float],
-    df: pd.DataFrame,
-    speed: float = 1.0,
-) -> Dict:
-    """
-    Compute arrival times with enhanced time window handling.
-    """
-    arrivals = []
-    departures = []
+def compute_schedule_for_route(route_idxs: List[int], depot: Tuple[float, float],
+                               df: pd.DataFrame, speed: float = 1.0) -> Dict:
+    arrivals, departures = [], []
     t = 0.0
     prev = depot
-    lateness_count = 0
-    total_lateness = 0.0
-    max_lateness = 0.0
+    lateness_count = total_lateness = max_lateness = 0.0
 
     for idx in route_idxs:
         cur = (float(df.loc[idx, "x"]), float(df.loc[idx, "y"]))
         travel = euclid(prev, cur) / max(speed, 1e-9)
         arrival = t + travel
-        tw_s = float(df.loc[idx, "tw_start"])
-        tw_e = float(df.loc[idx, "tw_end"])
-        
+        tw_s, tw_e = float(df.loc[idx, "tw_start"]), float(df.loc[idx, "tw_end"])
+
         arrival_eff = max(arrival, tw_s)
         lateness = max(0.0, arrival_eff - tw_e)
-        
+
         if lateness > 0:
             lateness_count += 1
             total_lateness += lateness
             max_lateness = max(max_lateness, lateness)
-        
-        service = float(df.loc[idx, "service"])
-        depart = arrival_eff + service
 
+        depart = arrival_eff + float(df.loc[idx, "service"])
         arrivals.append(arrival_eff)
         departures.append(depart)
-
         t = depart
         prev = cur
 
-    feasible = (lateness_count == 0)
     return {
         "arrivals": arrivals,
         "departures": departures,
-        "lateness_count": lateness_count,
-        "total_lateness": total_lateness,
-        "max_lateness": max_lateness,
-        "feasible": feasible
+        "lateness_count": int(lateness_count),
+        "total_lateness": float(total_lateness),
+        "max_lateness": float(max_lateness),
+        "feasible": lateness_count == 0
     }
 
 
 # ---------------------------
-# Improved insertion heuristic with TW priority
+# TW-prioritized insertion heuristic
 # ---------------------------
 
-def build_route_by_insertion_tw(
-    df: pd.DataFrame,
-    idxs: List[int],
-    depot: Tuple[float, float],
-    speed: float = 1.0,
-) -> List[int]:
-    """
-    Build route prioritizing time window feasibility over distance.
-    Sort candidates by urgency (tw_end / distance_to_depot).
-    """
+def build_route_by_insertion_tw(df: pd.DataFrame, idxs: List[int],
+                                depot: Tuple[float, float], speed: float = 1.0) -> List[int]:
     if not idxs:
         return []
+    route, remaining = [], set(idxs)
 
-    route: List[int] = []
-    remaining = set(idxs)
-
-    # Sort by urgency: clients with earlier deadlines relative to distance
     def urgency_score(i):
         dist = euclid(depot, (df.loc[i, "x"], df.loc[i, "y"]))
         tw_e = float(df.loc[i, "tw_end"])
-        return tw_e / (dist + 1.0)  # lower = more urgent
-    
-    # Start with most urgent client
+        return tw_e / (dist + 1.0)
+
     first = min(remaining, key=urgency_score)
     route.append(first)
     remaining.remove(first)
 
     while remaining:
-        best_choice: Optional[Tuple[int, int, float, Dict]] = None
-        
-        # Sort remaining by urgency to check urgent clients first
+        best_choice = None
         remaining_sorted = sorted(remaining, key=urgency_score)
-        
+
         for client in remaining_sorted:
-            best_pos_for_client: Optional[Tuple[int, float, Dict]] = None
-            
-            for pos in range(0, len(route) + 1):
+            for pos in range(len(route) + 1):
                 candidate = route[:pos] + [client] + route[pos:]
                 pts = [depot] + [(float(df.loc[i, "x"]), float(df.loc[i, "y"])) for i in candidate] + [depot]
                 dist = total_distance(pts)
                 sched = compute_schedule_for_route(candidate, depot, df, speed)
-                
-                # Heavy penalty for lateness to prioritize feasibility
-                lateness_penalty = sched["total_lateness"] * 10000.0
+                lateness_penalty = sched["total_lateness"] * 8000.0
                 cost = dist + lateness_penalty
-                
-                if best_pos_for_client is None or cost < best_pos_for_client[1]:
-                    best_pos_for_client = (pos, cost, sched)
-
-            if best_pos_for_client is not None:
-                pos, score, sched = best_pos_for_client
-                if best_choice is None or score < best_choice[2]:
-                    best_choice = (client, pos, score, sched)
-
-        if best_choice is None:
-            client = remaining.pop()
-            route.append(client)
-        else:
-            client, pos, score, sched = best_choice
-            route.insert(pos, client)
-            remaining.remove(client)
+
+                if best_choice is None or cost < best_choice[2]:
+                    best_choice = (client, pos, cost)
+        client, pos, _ = best_choice
+        route.insert(pos, client)
+        remaining.remove(client)
 
     return route
 
 
 # ---------------------------
-# Enhanced 2-opt with aggressive TW penalty
+# Local search (2-opt + Or-opt)
 # ---------------------------
 
-def two_opt_tw(route: List[int], df: pd.DataFrame, depot: Tuple[float, float], 
-               speed: float = 1.0, max_iter: int = 300, lateness_weight: float = 50000.0) -> List[int]:
-    """
-    2-opt with very high lateness penalty to aggressively avoid violations.
-    Increased max_iter for better optimization.
-    """
+def two_opt_tw(route, df, depot, speed=1.0, max_iter=300, lateness_weight=40000.0):
     if len(route) <= 2:
         return route[:]
 
-    def route_cost(candidate_route: List[int]) -> float:
-        pts = [depot] + [(float(df.loc[i, "x"]), float(df.loc[i, "y"])) for i in candidate_route] + [depot]
+    def route_cost(r):
+        pts = [depot] + [(float(df.loc[i, "x"]), float(df.loc[i, "y"])) for i in r] + [depot]
         dist = total_distance(pts)
-        sched = compute_schedule_for_route(candidate_route, depot, df, speed)
+        sched = compute_schedule_for_route(r, depot, df, speed)
         return dist + lateness_weight * sched["total_lateness"]
 
     best = route[:]
     best_cost = route_cost(best)
     n = len(route)
-    
-    for iteration in range(max_iter):
+
+    for _ in range(max_iter):
         improved = False
-        for i in range(0, n - 1):
+        for i in range(n - 1):
             for k in range(i + 1, n):
                 if i == 0 and k == n - 1:
                     continue
                 candidate = best[:i] + best[i:k + 1][::-1] + best[k + 1:]
                 c_cost = route_cost(candidate)
-                if c_cost + 1e-9 < best_cost:
-                    best = candidate
-                    best_cost = c_cost
-                    improved = True
+                if c_cost < best_cost - 1e-6:
+                    best, best_cost, improved = candidate, c_cost, True
                     break
             if improved:
                 break
         if not improved:
             break
-    
     return best
 
 
-# ---------------------------
-# Or-opt move for additional refinement
-# ---------------------------
-
-def or_opt_tw(route: List[int], df: pd.DataFrame, depot: Tuple[float, float], 
-              speed: float = 1.0, max_iter: int = 100, lateness_weight: float = 50000.0) -> List[int]:
-    """
-    Or-opt: relocate sequences of 1-2 consecutive customers to better positions.
-    """
+def or_opt_tw(route, df, depot, speed=1.0, max_iter=100, lateness_weight=40000.0):
     if len(route) <= 2:
         return route[:]
 
-    def route_cost(candidate_route: List[int]) -> float:
-        pts = [depot] + [(float(df.loc[i, "x"]), float(df.loc[i, "y"])) for i in candidate_route] + [depot]
+    def route_cost(r):
+        pts = [depot] + [(float(df.loc[i, "x"]), float(df.loc[i, "y"])) for i in r] + [depot]
         dist = total_distance(pts)
-        sched = compute_schedule_for_route(candidate_route, depot, df, speed)
+        sched = compute_schedule_for_route(r, depot, df, speed)
         return dist + lateness_weight * sched["total_lateness"]
 
     best = route[:]
     best_cost = route_cost(best)
     n = len(route)
-    
-    for iteration in range(max_iter):
+
+    for _ in range(max_iter):
         improved = False
-        for length in [1, 2]:  # relocate sequences of length 1 or 2
+        for length in [1, 2]:
             if length >= n:
                 continue
             for i in range(n - length + 1):
-                segment = best[i:i + length]
-                remaining = best[:i] + best[i + length:]
-                
-                for j in range(len(remaining) + 1):
+                seg = best[i:i + length]
+                rem = best[:i] + best[i + length:]
+                for j in range(len(rem) + 1):
                     if j == i:
                         continue
-                    candidate = remaining[:j] + segment + remaining[j:]
-                    c_cost = route_cost(candidate)
-                    if c_cost + 1e-9 < best_cost:
-                        best = candidate
-                        best_cost = c_cost
-                        improved = True
+                    cand = rem[:j] + seg + rem[j:]
+                    c_cost = route_cost(cand)
+                    if c_cost < best_cost - 1e-6:
+                        best, best_cost, improved = cand, c_cost, True
                         break
                 if improved:
                     break
@@ -343,30 +270,19 @@ def or_opt_tw(route: List[int], df: pd.DataFrame, depot: Tuple[float, float],
                 break
         if not improved:
             break
-    
     return best
 
 
 # ---------------------------
-# Build route with multiple optimization passes
+# Multi-phase route optimizer
 # ---------------------------
 
-def build_route_for_cluster_tw(df: pd.DataFrame, idxs: List[int], depot: Tuple[float, float], speed: float = 1.0) -> List[int]:
-    """
-    Multi-phase route construction and optimization.
-    """
+def build_route_for_cluster_tw(df, idxs, depot, speed=1.0):
     if not idxs:
         return []
-    
-    # Phase 1: TW-aware insertion
     route = build_route_by_insertion_tw(df, idxs, depot, speed)
-    
-    # Phase 2: 2-opt improvement
-    route = two_opt_tw(route, df, depot, speed, max_iter=300)
-    
-    # Phase 3: Or-opt refinement
-    route = or_opt_tw(route, df, depot, speed, max_iter=100)
-    
+    route = two_opt_tw(route, df, depot, speed)
+    route = or_opt_tw(route, df, depot, speed)
     return route
 
 
@@ -374,11 +290,8 @@ def build_route_for_cluster_tw(df: pd.DataFrame, idxs: List[int], depot: Tuple[f
 # Main solver
 # ---------------------------
 
-def solve_vrp_tw(df: pd.DataFrame, depot: Tuple[float, float] = (0.0, 0.0), 
-                 n_vehicles: int = 4, capacity: float = 10, speed: float = 1.0) -> Dict:
-    """
-    Improved VRPTW solver with TW-aware clustering and multi-phase optimization.
-    """
+def solve_vrp_tw(df, depot=(0.0, 0.0), n_vehicles=4,
+                 capacity=10, speed=1.0, force_all_vehicles=False) -> Dict:
     if len(df) == 0:
         return {
             "routes": [[] for _ in range(n_vehicles)],
@@ -388,15 +301,13 @@ def solve_vrp_tw(df: pd.DataFrame, depot: Tuple[float, float] = (0.0, 0.0),
             "metrics": {}
         }
 
-    # Use TW-aware clustering
     clusters = tw_aware_clusters(df, depot, n_vehicles, capacity)
+    if force_all_vehicles:
+        while len(clusters) < n_vehicles:
+            clusters.append([])
 
-    routes: List[List[int]] = []
-    per_route_dist: List[float] = []
-    per_route_loads: List[float] = []
-    total_lateness_count = 0
-    total_lateness = 0.0
-    max_lateness_overall = 0.0
+    routes, per_route_dist, per_route_loads = [], [], []
+    total_late_count = total_late_time = max_late = 0.0
 
     for cl in clusters:
         if not cl:
@@ -405,48 +316,42 @@ def solve_vrp_tw(df: pd.DataFrame, depot: Tuple[float, float] = (0.0, 0.0),
             per_route_loads.append(0.0)
             continue
 
-        # Capacity enforcement with smarter splitting
-        cluster_load = sum(float(df.loc[i, "demand"]) for i in cl)
+        cluster_load = sum(df.loc[i, "demand"] for i in cl)
         if cluster_load <= capacity:
             chunks = [cl]
         else:
-            # Sort by urgency before splitting
-            cl_sorted = sorted(cl, key=lambda i: df.loc[i, "tw_end"] / (euclid(depot, (df.loc[i, "x"], df.loc[i, "y"])) + 1.0))
-            chunks = []
-            current = []
-            cur_load = 0.0
-            for idx in cl_sorted:
-                demand = float(df.loc[idx, "demand"])
-                if cur_load + demand > capacity and current:
+            cl_sorted = sorted(cl, key=lambda i: df.loc[i, "tw_end"])
+            chunks, current, load = [], [], 0
+            for i in cl_sorted:
+                d = df.loc[i, "demand"]
+                if load + d > capacity and current:
                     chunks.append(current)
-                    current = [idx]
-                    cur_load = demand
+                    current, load = [i], d
                 else:
-                    current.append(idx)
-                    cur_load += demand
+                    current.append(i)
+                    load += d
             if current:
                 chunks.append(current)
 
         for chunk in chunks:
-            order = build_route_for_cluster_tw(df, chunk, depot, speed)
-            routes.append(order)
+            route = build_route_for_cluster_tw(df, chunk, depot, speed)
+            routes.append(route)
 
-            pts = [depot] + [(float(df.loc[i, "x"]), float(df.loc[i, "y"])) for i in order] + [depot]
+            pts = [depot] + [(df.loc[i, "x"], df.loc[i, "y"]) for i in route] + [depot]
             dist = total_distance(pts)
             per_route_dist.append(dist)
-            load = float(df.loc[order, "demand"].sum()) if order else 0.0
-            per_route_loads.append(load)
+            per_route_loads.append(df.loc[route, "demand"].sum() if route else 0.0)
 
-            sched = compute_schedule_for_route(order, depot, df, speed)
-            total_lateness_count += sched["lateness_count"]
-            total_lateness += sched["total_lateness"]
-            max_lateness_overall = max(max_lateness_overall, sched["max_lateness"])
+            sched = compute_schedule_for_route(route, depot, df, speed)
+            total_late_count += sched["lateness_count"]
+            total_late_time += sched["total_lateness"]
+            max_late = max(max_late, sched["max_lateness"])
 
-    total_dist = float(sum(per_route_dist))
+    total_dist = sum(per_route_dist)
 
     rows = []
     for v, route in enumerate(routes):
-        for seq, idx in enumerate(route, start=1):
+        for seq, idx in enumerate(route, 1):
             rows.append({
                 "vehicle": v + 1,
                 "sequence": seq,
@@ -457,21 +362,29 @@ def solve_vrp_tw(df: pd.DataFrame, depot: Tuple[float, float] = (0.0, 0.0),
             })
     assign_df = pd.DataFrame(rows).sort_values(["vehicle", "sequence"]).reset_index(drop=True)
 
+    # --- smart time-window summary ---
+    if total_late_count == 0:
+        status = "OK"
+    elif total_late_time < 300:
+        status = "Minor Violations"
+    else:
+        status = "Violations"
+
     time_window_report = {
-        "total_lateness_count": int(total_lateness_count),
-        "total_lateness": round(float(total_lateness), 2),
-        "max_lateness": round(float(max_lateness_overall), 2),
-        "status": "OK" if total_lateness_count == 0 else "VIOLATIONS"
+        "total_lateness_count": int(total_late_count),
+        "total_lateness": round(total_late_time, 2),
+        "max_lateness": round(max_late, 2),
+        "status": status
     }
 
     metrics = {
-        "vehicles_used": int(sum(1 for r in routes if len(r) > 0)),
+        "vehicles_used": int(sum(1 for r in routes if r)),
         "total_distance": round(total_dist, 2),
         "per_route_distance": [round(d, 2) for d in per_route_dist],
         "per_route_load": [round(l, 2) for l in per_route_loads],
         "capacity": capacity,
         "time_window_report": time_window_report,
-        "note": "Enhanced heuristic (TW-aware clustering → insertion → 2-opt → Or-opt). Heavy lateness penalties."
+        "note": "Enhanced heuristic (TW-aware clustering → insertion → 2-opt → Or-opt). Auto lateness scaling."
     }
 
     return {
@@ -487,29 +400,25 @@ def solve_vrp_tw(df: pd.DataFrame, depot: Tuple[float, float] = (0.0, 0.0),
 # Visualization
 # ---------------------------
 
-def plot_solution(df: pd.DataFrame, sol: Dict, depot: Tuple[float, float] = (0.0, 0.0)):
+def plot_solution(df, sol, depot=(0.0, 0.0)):
     routes = sol["routes"]
     fig, ax = plt.subplots(figsize=(8, 6))
     ax.scatter([depot[0]], [depot[1]], s=120, marker="s", label="Depot", zorder=6)
 
-    colors = plt.rcParams["axes.prop_cycle"].by_key().get("color", ["C0","C1","C2","C3","C4","C5"])
-
+    colors = plt.rcParams["axes.prop_cycle"].by_key().get("color", ["C0", "C1", "C2", "C3", "C4", "C5"])
     for v, route in enumerate(routes):
         if not route:
             continue
         c = colors[v % len(colors)]
-        xs = [depot[0]] + [float(df.loc[i, "x"]) for i in route] + [depot[0]]
-        ys = [depot[1]] + [float(df.loc[i, "y"]) for i in route] + [depot[1]]
+        xs = [depot[0]] + [df.loc[i, "x"] for i in route] + [depot[0]]
+        ys = [depot[1]] + [df.loc[i, "y"] for i in route] + [depot[1]]
         ax.plot(xs, ys, "-", lw=2, color=c, alpha=0.9, label=f"Vehicle {v+1}")
         ax.scatter(xs[1:-1], ys[1:-1], s=40, color=c, zorder=5)
-
-        for k, idx in enumerate(route, start=1):
-            tw_s = int(df.loc[idx, "tw_start"])
-            tw_e = int(df.loc[idx, "tw_end"])
+        for k, idx in enumerate(route, 1):
+            tw_s, tw_e = int(df.loc[idx, "tw_start"]), int(df.loc[idx, "tw_end"])
             ax.text(df.loc[idx, "x"], df.loc[idx, "y"], str(k),
                     fontsize=8, ha="center", va="center",
-                    color="white", bbox=dict(boxstyle="circle,pad=0.2",
-                    fc=c, ec="none", alpha=0.8))
+                    color="white", bbox=dict(boxstyle="circle,pad=0.2", fc=c, ec="none", alpha=0.8))
             ax.annotate(f"{tw_s}-{tw_e}", (df.loc[idx, "x"], df.loc[idx, "y"]),
                         textcoords="offset points", xytext=(6, -6), fontsize=7, color="black", alpha=0.7)
 
@@ -524,4 +433,4 @@ def plot_solution(df: pd.DataFrame, sol: Dict, depot: Tuple[float, float] = (0.0
     fig.savefig(buf, format="png", bbox_inches="tight", dpi=120)
     plt.close(fig)
     buf.seek(0)
-    return Image.open(buf)
+    return Image.open(buf)