FleetFlow - A Time-Budgeted CVRP/VRPTW Solver

Minimal, original solver for Capacitated Vehicle Routing with optional Time Windows.

Comment

Inspiration

Modern e-commerce, logistics, and urban delivery systems burn billions of miles annually, with direct financial and CO₂ costs. Yet most small-to-medium businesses cannot afford expensive proprietary solvers. I wanted to show that a clean, original, algorithmic solution can deliver near-state-of-the-art performance under strict time budgets - reproducible, transparent, and hackathon-friendly.

What it does

FleetFlow is a minimal but powerful solver for the Capacitated Vehicle Routing Problem (CVRP) and its variant with Time Windows (VRPTW). It takes a depot and hundreds to thousands of customer locations with demands, and outputs optimized delivery routes for a fixed fleet of vehicles.

  • Minimizes total distance traveled (proxy for cost & emissions).
  • Respects vehicle capacity and optional time windows.
  • Provides results within a predictable runtime budget (e.g., “good solution in 10 seconds”).
  • Produces artifacts: JSON logs, plots of routes, runtime curves, and environment metadata for full reproducibility.

How we built it

We implemented everything from scratch (no OR-Tools or black-box solvers), in modular Python code:

  1. Synthetic VRP dataset generator (src/model.py) - produces reproducible Euclidean instances with random seeds, demands, optional time windows, and fairness knobs.
  2. Initialization - Clarke–Wright (CW) Savings heuristic constructs feasible tours quickly.
  3. Local search - 2-opt (removes crossings, improves individual tours) and Relocate (moves customers between routes).
  4. Meta-heuristic - Time-budgeted Simulated Annealing (SA) with O(1) edge deltas; accepts uphill moves to escape local minima.
  5. Evaluation suite - CLI (src/cli.py) for single runs, src/eval.py for sweeps, scripts/summarize_sweep.py for tables, and scripts/plot_runtime.py for charts.
  6. Visualization - Matplotlib route plots and runtime scaling curves. Artifacts (results/) capture every experiment: costs, runtimes, plots, and environment metadata (Python/OS/CPU/seed).

Challenges we ran into

  • Ensuring feasible merges in Clarke–Wright without breaking capacity rules.
  • Writing constant-time move evaluations for 2-opt and Relocate so that large instances run within seconds.
  • Designing a time-budgeted SA loop that balances diversification with reproducibility.
  • Communicating results clearly: normalizing cost per customer, logging environment, and producing sweep tables that judges can understand at a glance.

Accomplishments that we're proud of

  • Built a fully original CVRP/VRPTW solver - no external solver libraries.
  • Achieved stable, scalable results up to N=1000 customers within ~10–12s.
  • Demonstrated clear improvements via ablation (CW → CW+Local → CW+Local+SA).
  • Logged full reproducibility artifacts (JSON, plots, env metadata).
  • Delivered a judge-friendly README and demo, tying the algorithm to real-world logistics impact (fuel savings, CO₂ reduction).

What we learned

  • How to implement classical heuristics + meta-heuristics from scratch and make them time-budgeted.
  • Importance of reproducibility: logging seeds, CPU, and OS makes results credible.
  • How customer density affects route cost (14.17 → 2.16 per customer as N grows).
  • The power of visualization and documentation - results are far more convincing when supported by plots and normalized metrics.

What's next for FleetFlow - A Time-Budgeted CVRP/VRPTW Solver

  • Extend to multi-depot VRP and heterogeneous fleets.
  • Incorporate traffic models (time-dependent travel times).
  • Richer fairness objectives (balancing workload across drivers).
  • Parallelization and GPU acceleration for larger N (>10,000).
  • Packaging as a microservice / API for dispatch platforms.

Team

Solo: Sweety Seelam

Built With

Share this project:

Updates