[Paper Review] Generalized Traveling Salesman Problem Reduction Algorithms

Gregory Gutin, Daniel Karapetyan|arXiv (Cornell University)|Apr 4, 2008

Vehicle Routing Optimization Methods17 references20 citations

TL;DR

This paper presents a polynomial-time preprocessing algorithm that reduces the Generalized Traveling Salesman Problem (GTSP) by eliminating redundant vertices and edges without altering the optimal solution. The method uses distance comparisons via a Differences Table to identify vertices that cannot be in any optimal tour, achieving 15–20% average problem size reduction and up to 60% faster solution times across multiple solvers.

ABSTRACT

The generalized traveling salesman problem (GTSP) is an extension of the well-known traveling salesman problem. In GTSP, we are given a partition of cities into groups and we are required to find a minimum length tour that includes exactly one city from each group. The aim of this paper is to present a problem reduction algorithm that deletes redundant vertices and edges, preserving the optimal solution. The algorithm's running time is O(N^3) in the worst case, but it is significantly faster in practice. The algorithm has reduced the problem size by 15-20% on average in our experiments and this has decreased the solution time by 10-60% for each of the considered solvers.

Motivation & Objective

• To reduce GTSP instance size by identifying and removing vertices and edges that cannot belong to any optimal solution.
• To develop a preprocessing technique that preserves optimality while significantly decreasing computational cost for GTSP solvers.
• To design a practical, efficient algorithm with low overhead that outperforms existing methods in real-world GTSP instances.
• To evaluate the effectiveness of vertex reduction, edge reduction, and their combination across multiple GTSP solvers.

Proposed method

• For vertex reduction, a vertex r in cluster C is deemed redundant if, for every pair of vertices x and y from other clusters, there exists another vertex s in C ∖ {r} such that dist(x,s) + dist(s,y) ≤ dist(x,r) + dist(r,y).
• A Differences Table is constructed to store Δₓʳ ⁻ ˢ = dist(x,r) − dist(x,s) for all x ∉ C and s ∈ C ∖ {r}, enabling efficient redundancy checks.
• Redundancy is verified by checking if the sum Δₓʳ ⁻ ˢ + Δᵧʳ ⁻ ˢ ≥ 0 for all pairs (x,y) from distinct clusters; if all such sums are negative, r is not redundant.
• The algorithm iteratively applies vertex reduction in cyclic order until no further reductions are possible, ensuring all detectable redundant vertices are removed.
• For edge reduction, edges are removed if they are not part of any feasible path between clusters, based on distance comparisons and cluster connectivity.
• A combined reduction technique applies both vertex and edge reduction sequentially, with the edge reduction step modified to handle infinite edge weights by adjusting solver compatibility.

Experimental results

Research questions

• RQ1 Can redundant vertices in GTSP be identified efficiently using distance comparisons without compromising solution quality?
• RQ2 How effective is the proposed vertex reduction algorithm in reducing GTSP instance size and solution time across diverse solvers?
• RQ3 Does edge reduction, which modifies edge weights to infinity, improve solver performance, and how does it interact with different solvers?
• RQ4 Can a combined reduction strategy outperform individual vertex or edge reduction techniques in terms of problem size reduction and solution speedup?

Key findings

• The proposed preprocessing algorithm reduces GTSP problem size by 15–20% on average across tested instances, significantly decreasing solution time.
• Solution time was reduced by 10–60% for each of the five GTSP solvers evaluated, with the most substantial gains observed in exact and heuristic solvers.
• The combined vertex and edge reduction technique consistently outperformed individual reductions, especially for solvers like GKK and SD, which benefited more from edge reduction.
• The preprocessing time was consistently lower than the solution time for all solvers, even for large instances, confirming its practical efficiency.
• The experimental complexity of the SD solver was estimated as Θ(N³), and the preprocessing overhead remained negligible compared to solution time, even for N = 265.
• The modified Local Search procedure in the GK heuristic, combined with preprocessing, improved solution quality slightly at a small cost in runtime, demonstrating synergy with reduction techniques.