Parallel, Asymptotically Optimal Algorithms for Moving Target Traveling Salesman Problems

Abstract

The Moving Target Traveling Salesman Problem (MT-TSP) seeks a trajectory that intercepts several moving targets, within a particular time window for each target. When generic nonlinear target trajectories or kinematic constraints on the agent are present, no prior algorithm guarantees convergence to an optimal MT-TSP solution. Therefore, we introduce the Iterated Random Generalized (IRG) TSP framework. The idea behind IRG is to alternate between randomly sampling a set of agent configuration-time points, corresponding to interceptions of targets, and finding a sequence of interception points by solving a generalized TSP (GTSP). This alternation asymptotically converges to the optimum. We introduce two parallel algorithms within the IRG framework. The first algorithm, IRG-PGLNS, solves GTSPs using PGLNS, our parallelized extension of state-of-the-art solver GLNS. The second algorithm, Parallel Communicating GTSPs (PCG), solves GTSPs for several sets of points simultaneously. We present numerical results for three MT-TSP variants: one where intercepting a target only requires coming within a particular distance, another where the agent is a variable-speed Dubins car, and a third where the agent is a robot arm. We show that IRG-PGLNS and PCG converge faster than a baseline based on prior work. We further validate our framework with physical robot experiments.

Figures (12)

• Figure 1: MT-TSP and three variants. In all images, targets (stars) move along trajectories with time windows shown in bold colored lines. Targets' locations are shown at $t = 0$. Agent's trajectory (blue) begins at initial configuration $q_0$ and intercepts all targets. We consider Hamiltonian paths, where the agent does not need to return to $q_0$. (a) MT-TSP, where the agent is limited by a maximum speed. (b) Close-Enough MT-TSP, where agent has a maximum speed, and each target is surrounded by a disc of positions where it may be intercepted. Filled discs are centered at the targets' positions at $t = 0$, and dashed, unfilled discs indicate disc locations at moment of interception. (c) Variable-Speed Dubins MT-TSP, where agent has a minimum speed, maximum speed, and a minimum turning radius that increases with speed. (d) Robot Arm MT-TSP. Agent is a 7-DOF arm (Kuka iiwa), where each joint has a speed limit. Intercepting a target requires matching the end-effector's pose with the target's pose. Poses are visualized at $t = 0$ with reference frames.
• Figure 2: Contributions of IRG framework. As discussed in Section \ref{['sec:mt_tsp']}, prior MT-TSP methods exist that sample trajectories of targets into points, then solve a GTSP stieber2022DealingWithTimephilip2025CStarLi2019RendezvousPlanningmathew2015multirobot. IRG improves upon these methods by iteratively generating new sample sets, contributing a new GTSP solver for the first set of samples, and accelerating convergence via two parallelization approaches.
• Figure 3: An iteration of tour improvement in IRG-PGLNS. The trajectory corresponding to the incumbent tour $\Gamma^*$ (the least-cost tour found so far) is shown in pink. Points in the incumbent are outlined in pink. To improve the incumbent, as seen in the right-hand box, we generate a set of sample points $\mathcal{S}_i$ for each target $i$, including random points and the point from the incumbent. We then solve a GTSP to find an updated incumbent.
• Figure 4: IRG-PGLNS sampling strategy applied to three MT-TSP variants. (a) Close-Enough MT-TSP: samples lie on disc boundaries. (b) Variable-Speed Dubins MT-TSP: a sample point's position matches the target's position at the sampled time, but the sample point's heading is random. (c) Robot Arm MT-TSP: each sample point is an arm configuration-time pair, where the end-effector pose for the arm configuration must match the target's pose at the sampled time. Target poses at sampled times are shown with reference frames.
• Figure 5: Illustration of an iteration of trajectory improvement in PCG. The main process maintains an informed set of points $\mathcal{S}_i^\dagger$ for each target $i$. Points in the current iteration's informed sets are outlined in pink. Each child process $j$ generates a set of sample points $\mathcal{S}_i^j$ for each target $i$, containing the points from the current $\mathcal{S}_i^\dagger$ and random points unique to process $j$. Each child process then solves a GTSP, finding a sequence of points beginning at ${q_{\textnormal{a},0}}$ visiting one point per target. The main process then updates the informed set for each target $i$ to contain all visited points associated with target $i$ from all child processes.

Theorems & Definitions (8)

• Theorem 1
• proof
• Lemma 1
• proof
• Lemma 2
• proof
• Theorem 2
• proof