How to Build a TSP Solver and Generator from Scratch

TSP Solver and Generator: Fast Algorithms for Optimal RoutesThe Traveling Salesman Problem (TSP) is a foundational optimization problem: given a set of cities and pairwise distances, find the shortest possible tour that visits each city exactly once and returns to the starting point. Despite its simple statement, TSP is NP-hard and remains one of the most studied problems in computer science, operations research, and applied mathematics. This article covers essential concepts, practical algorithmic approaches, generator design for test instances, engineering considerations for performance, and practical tips for applying TSP solvers to real-world routing problems.

---

Why TSP matters

TSP is more than an academic exercise. It models many real-world problems:

• vehicle routing and logistics,
• circuit board drilling and manufacturing,
• DNA sequencing and computational biology (as subproblems),
• scheduling and production planning,
• network design and inspection paths.

Because TSP encapsulates core combinatorial complexity, progress in TSP algorithms often transfers to broader optimization domains.

---

Problem definition and representations

Formally, given a complete weighted graph G = (V, E) with |V| = n and nonnegative edge weights w(u, v), find a permutation π of V that minimizes the tour length:

L(π) = sum_{i=1..n} w(πi, π{i+1}), with π_{n+1} = π_1.

Common representations:

• distance matrix (n×n) — convenient for dense and exact algorithms,
• coordinate list (Euclidean instances) — allows geometric heuristics and fast nearest-neighbor queries,
• adjacency lists (sparse graphs) — when not all edges exist.

Instance types:

• Euclidean TSP (distances from planar coordinates, metric and symmetric),
• Metric TSP (triangle inequality holds),
• Asymmetric TSP (w(u,v) ≠ w(v,u)),
• General TSP (no restrictions).

---

Generators: creating test instances

A good generator helps benchmark solvers and explore algorithmic behavior. Typical generators:

1. Random Euclidean instances:

   • Sample n points uniformly in the unit square (or other domain).
   • Use Euclidean distance (or rounded integer distances).
   • Add clustering by sampling from mixtures of Gaussians to simulate real-world point clouds.

2. Grid and structured instances:

   • Regular grids, perturbed grids, circles — useful to test geometric heuristics.

3. Hard instances:

   • Constructed instances like the TSPLIB instances or adversarial constructions highlight worst-case behavior.
   • Use distance perturbations, long skinny clusters, or near-degenerate configurations that foil greedy heuristics.

4. Asymmetric instances:

   • Generate directed edge weights, for example by assigning random travel times with direction-dependent components (wind, one-way streets).

Implementation tips:

• Allow seed control for reproducibility.
• Offer options for metric vs. non-metric distances, rounding, and coordinate distribution.
• Provide output in standard formats (TSPLIB .tsp, CSV distance matrix, JSON).

Example generator pseudocode (Euclidean):

import random, math def generate_euclidean(n, width=1.0, height=1.0, seed=None):     random.seed(seed)     points = [(random.random()*width, random.random()*height) for _ in range(n)]     def dist(i,j):         (x1,y1),(x2,y2) = points[i], points[j]         return math.hypot(x1-x2, y1-y2)     return points, dist 

---

Exact algorithms

Exact solvers find provably optimal tours. They are exponential in worst-case complexity but practical for moderate n with strong pruning.

1. Dynamic Programming (Held–Karp)

   • Complexity O(n^2 2^n) time, O(n 2^n) memory.
   • Uses bitmask DP over subsets.
   • Practical up to n ≈ 40 with optimized implementations.
   • Easy to implement and useful as a baseline.

2. Branch and Bound (B&B)

   • Explores permutations tree; prunes branches using lower bounds (1-tree, assignment relaxation, reduced costs).
   • Combine successive reductions and heuristics to get strong bounds early.
   • Works well on many structured instances and is the backbone of high-performance exact TSP solvers (Concorde).

3. Cutting Planes and Branch-and-Cut

   • Formulate TSP as an integer linear program (ILP) and iteratively add violated subtour elimination or comb inequalities.
   • Modern solvers (Concorde, CPLEX with custom cuts) can solve large instances by combining LP relaxations with branch-and-cut.
   • Very effective when paired with symmetry-breaking and problem-specific cuts.

Practical tips:

• Use heuristic solutions early to get good upper bounds for pruning.
• Use bitset data structures and low-level optimizations for DP.
• Exploit problem structure: symmetric vs asymmetric, sparsity, Euclidean geometry.

---

Heuristics and approximation algorithms

For larger n or when near-instant solutions are needed, heuristics and approximation algorithms perform well.

1. Construction heuristics

   • Nearest Neighbor (fast O(n^2)): greedy, but can be poor.
   • Greedy edge insertion: add shortest feasible edges without creating subtours.
   • Christofides’ algorithm (metric TSP): guarantees 1.5-approximation for symmetric metric TSP — builds MST, finds minimum-weight matching on odd-degree vertices, and shortcuts Euler tour. Good theoretical guarantee and often good practical performance.

2. Local search and improvement

   • 2-opt and 3-opt: swap edges to remove crossings and improve tour length. 2-opt is simple and powerful; 3-opt captures more complex improvements.
   • k-opt generalizations: variable k improves quality but increases cost.
   • Lin–Kernighan (LK) and Lin–Kernighan-Helsgaun (LKH):
     • Widely regarded as state-of-the-art heuristics for large-scale TSP.
     • Adaptive k-opt search, clever candidate sets, and efficient implementation yield near-optimal tours for thousands of nodes.

3. Metaheuristics

   • Simulated Annealing: probabilistic acceptance of worse moves to escape local minima.
   • Genetic Algorithms / Evolutionary Strategies: evolve populations of tours using crossover and mutation.
   • Ant Colony Optimization: pheromone-based probabilistic construction; good for various combinatorial problems.
   • Tabu Search: records recent moves to avoid cycles.

4. Hybrid methods

   • Combine local search with metaheuristics or exact methods (e.g., run LKH to get a solution and then polish via branch-and-cut).

Practical performance rules:

• Use candidate sets (nearest neighbors) to limit search space for k-opt moves.
• Maintain quick incremental evaluation of move cost to avoid recomputing tour lengths.
• Use time-bounded runs that progressively improve solutions; many heuristics show diminishing returns after a short time.

---

Data structures and implementation techniques

Efficient solvers rely on careful engineering.

• Tour representation:

  • Doubly linked list of nodes for O(1) segment reversals (useful in k-opt).
  • Arrays with positional indices when many random accesses needed.

• Candidate sets:

  • Precompute for each node a small set of nearest neighbors to restrict considered swaps.

• Distance representations:

  • Precompute and store distances when memory allows (n^2 matrix).
  • Use on-the-fly computation for very large n where n^2 storage is infeasible.

• Fast evaluation of k-opt moves:

  • Update delta costs incrementally.
  • Use move filters (accept only moves that reduce by a threshold) to prune attempts.

• Parallelism:

  • Run multiple heuristic restarts in parallel with different random seeds.
  • Parallelize candidate evaluation and local improvement steps where independent.

• Numerical robustness:

  • Use integer distances when possible to avoid floating-point accumulation issues.
  • Carefully manage rounding if converting real distances to integer weights (e.g., scaling).

---

Evaluating and benchmarking solvers

Good evaluation practices:

• Use standard datasets (TSPLIB) and synthetic generators with controlled properties.
• Report average and best performance across seeds and instance families.
• Measure time-to-target: time needed to reach a solution within X% of optimal.
• Track memory usage and scalability.
• Include statistical variability: boxplots or percentiles for stochastic methods.

Comparison table (example pros/cons)

Method	Strengths	Weaknesses
Held–Karp DP	Exact, simple conceptually	Exponential time/memory; limited to small n
Branch-and-Cut	Solves large instances optimally (with engineering)	Complex to implement; heavy LP work
Christofides	1.5-approx guarantee (metric)	Requires matching step; quality varies
LKH / Lin–Kernighan	Excellent practical quality; scalable	Complex; many tuning choices
Genetic / ACO	Flexible, parallelizable	Often slower to converge; parameter tuning

---

Case studies and practical examples

1. Logistics company with 200 stops:

   • Use LKH to generate near-optimal routes in seconds.
   • Post-process with time windows and capacity constraints (transform to VRP/VRPTW).

2. PCB drilling (thousands of holes):

   • Use Euclidean instance generator with clustered points.
   • Run multi-start 2-opt/3-opt with candidate sets; parallelize on multiple cores.

3. Research benchmark:

   • Compare implementations on TSPLIB instances.
   • Report optimality gap and time-to-target across multiple seeds.

---

Extensions and real-world considerations

Real problems often add constraints that convert TSP into other problems:

• Vehicle Routing Problem (VRP): multiple vehicles, capacities, time windows.
• Prize-Collecting TSP / Orienteering: maximize reward with length budget.
• Time-dependent or dynamic TSP: travel times vary over time (rush hour).
• Stochastic and robust variants: uncertainty in demands or travel times.

Approach: reduce to TSP where possible, otherwise adapt heuristics (e.g., LKH adaptations) or use problem-specific metaheuristics/ILP formulations.

---

Putting it together: design checklist for a solver + generator package

• Generator features: random Euclidean, clustered, grid, asymmetric; seedable; export formats.
• Solver core: implement fast heuristics (2-opt/3-opt, LKH-style), one exact method (Held–Karp or B&B), and ILP interface for branch-and-cut.
• Utilities: visualizer, instance profiler, benchmark harness, result serializer.
• Performance: candidate sets, incremental move evaluation, parallelism, memory-efficient distance handling.
• API: allow time limits, seed control, custom distance functions, and callbacks for intermediate solutions.

---

Conclusion

TSP remains a touchstone problem combining deep theory and practical impact. For many real-world routing tasks, well-engineered heuristics like Lin–Kernighan (and its descendants) provide near-optimal routes quickly, while exact methods and branch-and-cut deliver provable optimality on smaller to moderate instances. A useful solver and generator package balances robust instance generation, fast heuristics, and the ability to escalate to exact methods when required. When building or choosing a TSP system, focus on instance realism, performance engineering (candidate sets, incremental updates), and flexible tooling for benchmarking and integration into larger applications.