Vector TSP: A Traveling Salesperson Problem with Racetrack-like Acceleration Constraints

TL;DR

This work introduces Vector TSP, a new NP-hard variant of the traveling salesperson problem where the traveler obeys discrete Racetrack-like acceleration constraints, and the cost counts the number of steps in a trajectory rather than total distance. It formalizes the Racetrack model and a two-layer interactive framework: a high-level tour algorithm and a trajectory oracle implemented via a multi-point A* to evaluate tours by their realizable trajectories. The paper proves NP-hardness through a reduction from Exact Cover, via a Continuous VectorTSP with Stops, and shows the boundedness of the configuration graph along with a one-dimensional cost formula, enabling tractable analysis. It also presents practical algorithms (FlipTour and Multi-Point A*) and experimental evidence that Euclidean TSP tours are often suboptimal for Vector TSP, suggesting that dedicated Vector TSP heuristics can yield substantial improvements for path planning and related robotics applications.

Abstract

We study a new version of the Traveling Salesperson Problem, called \VectorTSP, where the traveler is subject to discrete acceleration constraints, as defined in the paper-and-pencil game Racetrack (also known as Vector Racer). In this model, the degrees of freedom at a certain point in time depends on the current velocity, and the speed is not limited. The paper introduces this problem and initiates its study, discussing also the main differences with existing versions of TSP. Not surprisingly, the problem turns out to be NP-hard. A key feature of \VectorTSP is that it deals with acceleration in a discrete, combinatorial way, making the problem more amenable to algorithmic investigation. The problem involves two layers of trajectory planning: (1) the order in which cities are visited, and (2) the physical trajectory realizing such a visit, both interacting with each other. This interaction is formalized as an interactive protocol between a high-level tour algorithm and a trajectory oracle, the former calling the latter repeatedly. We present an exact implementation of the trajectory oracle, adapting the A* algorithm for paths over multiple checkpoints whose ordering is \emph{given} (this algorithm being possibly of independent interest). To motivate the problem further, we perform experiments showing that the naive approach consisting of solving the instance as an \EuclideanTSP first, then optimizing the trajectory of the resulting tour, is typically suboptimal and outperformed by simple (but dedicated) heuristics.

Figures (12)

• Figure 1: Example of a trajectory in the Racetrack model.
• Figure 2: On the left, a trajectory in racetrack($\pi$), where $\pi$ is an optimal tour for Euclidean TSP; on the right, an optimal Vector TSP solution using less vectors along a different tour. The loop on $p_0$ illustrates the final "move" required to finish at zero speed. The alternation of colors is used to help distinguish individual moves.
• Figure 3: Computation of an optimal (one dimensional) trajectory for $k = 12$.
• Figure 4: Papadimitriou's high-level construction
• Figure 5: 1-chain structure which turns $90^{\circ}$ twice. The distance between consecutive cities is 1. The optimal visit order is shown in $(b)$. We abbreviate a 1-chain schematically as shown in $(c)$.

Theorems & Definitions (31)

• lemma thmcounterlemma
• proof
• lemma thmcounterlemma: Length of an optimal solution
• proof
• lemma thmcounterlemma: Bounds on the configuration graph
• proof
• corollary thmcountercorollary
• lemma thmcounterlemma
• proof
• lemma thmcounterlemma: Papadimitriou papadimitriou1977euclidean