Papers for

robotic path planners

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Polynomial time algorithm solves path cover reconfiguration on trees

A Polynomial-Time Algorithm for $k$-Path Vertex Cover Reconfiguration on Trees under Token Sliding

Abstract: A $k$-path vertex cover ($k$-PVC) of a graph is a set of vertices meeting every path on $k$ vertices. In Token Sliding, one token occupies each vertex of a cover; a move slides one token along an edge to an unoccupied vertex, preserving the cover property. We study whether two covers of a tree are joined by such moves. The case $k=2$ admits a linear-time decision algorithm. For every integer $k\geq2$, we give an $O(kn^2)$-time decision algorithm on trees of order $n$, with $k$ part of the input. Two covers are reachable precisely when their rigid tokens, which never move, occupy the same set and every component remaining after their deletion has the same token count. The proof transforms configurations of equal size without rigid tokens into a canonical configuration built on properly rooted subtrees, whose paths on $k$ vertices pass through their roots. A rooted-subtree recurrence identifies movable candidate tokens. We also give a direct recursive construction between the supplied endpoints, returning at most $8n^2\,3^{\lceil n/2\rceil}$ slides in $O(n^{10}3^{n/2})$ time. ChatGPT 6 Pro and Claude Fable 5.1 were used to assist with developing and reviewing mathematical arguments and drafting and revising the paper. The author takes full responsibility for the correctness and content of the paper.

Thu 22 OctData Structures and AlgorithmsDiscrete Mathematics
The gist
The paper studies a puzzle where you want to rearrange tokens placed on a tree’s vertices so that certain conditions are always met. Specifically, these tokens must always cover every path of a certain length (k) in the tree, and tokens can only slide to adjacent empty vertices. The authors found a way to decide efficiently if one arrangement of tokens can be turned into another using these slides, even when the path length k is part of the input. Their method breaks the problem down into simpler parts of the tree and identifies tokens that must stay fixed, allowing them to solve the problem in polynomial time.
Open → 2610.31261v1

Minimum 93-move solution found for complex crystal-exchange puzzle

An Exact 93-Move Solution to a Nonlocal Crystal-Exchange Puzzle

Abstract: We determine the minimum number of directional commands needed to solve alevel of Order of the Sinking Star, modeled as a crystal-exchangepuzzle on an 11*11 board. A command swapsthe player with the nearest crystal in the selected row or column, regardlessof distance; only an empty ray permits an ordinary unit walk. Two gates admitthe player to the exit exactly while all sixteen crystals occupy their targetcells. We give an explicit 93-command solution and exclude every shortersolution by an exact, cost-bounded breadth-first search. The search representsa position by its seventeen occupied cells and one active cell. Its admissibleheuristic partitions command costs between a compressed core abstraction andresidual motion, strengthened by a necessary activation detour and a cornervisit condition. The completed computation retained 605,349,215 occupied setsand 1,863,925,136 states. We prove the reductions and pruning conditions,describe the exact storage scheme, and provide source code, execution logs,and a reproduction driver. The result is a computer-assisted proof for thespecified instance, with an explicit implementation trust boundary.

Wed 21 OctArtificial Intelligence
The gist
This paper solves a tricky puzzle game where a player must swap places with crystals on a board and reach an exit with specific conditions. The puzzle involves commands that move the player by swapping positions with crystals along rows or columns. The authors found the shortest exact sequence of 93 moves needed to win this game and proved that no shorter solution exists. They used a detailed computer search method that carefully tracked all possible game states and moves, supported by clever rules to reduce the search space. The result is a computer-verified proof including all steps and code used.
Open → 2610.29493v1

Planar point sets divided fairly among agents with few straight lines

Splitting Planar Necklaces with Few Straight Cuts

Abstract: In the classical necklace splitting problem, beads of different colors lie on a line, and the goal is to divide them among $k$ agents using as few cuts as possible so that every agent receives the same number of beads of each color. We study the planar analog in which a cut is a full straight line and the objective is minimizing the number of lines: $m$ points colored red and blue must be separated by straight-line cuts into regions that can be allocated to $k$ agents so that each agent receives the same number of points of each color. Projection to a line gives $2(k-1)$ cuts, and $k-1$ are sometimes necessary; we give algorithms, static and dynamic, that provably close part of this gap. We develop several approaches that capitalize on the extra degree of freedom: a ``star'' search that produces solutions with as few as $\lceil \frac{k}{2} \rceil$ cuts and never more than $k$ whenever a fair contiguous circular partition exists, with further guarantees for evenly spaced input, and a general algorithm that produces at most $k + \log_2(k+1) - 2$ cuts in $Θ(m \log k)$ time, built on a one-dimensional necklace splitting subroutine that requires no presorting. We then adapt the general algorithm to a dynamic setting, maintaining exact fairness and the cut bound under arbitrary relocation of points, with expected update time that scales with the total distance moved.

Tue 20 OctComputational GeometryData Structures and AlgorithmsComputer Science and Game Theory
The gist
This paper looks at dividing colored points on a flat surface evenly among several people using just a few straight cuts. Normally, dividing colored beads on a line is well known, but this research explores the more complex puzzle of doing it on a plane with straight lines that cut across all points. The authors developed new methods that use fewer lines than previously required, sometimes reducing the number nearly by half compared to simple approaches. They also created efficient algorithms that adapt when points move, keeping divisions fair without many extra cuts.
Open → 2610.27956v1

Minimum spanning trees for crop plot access are hard to find

Minimum Spanning Trees for Square Crop Plots

Abstract: Motivated by accessing crop plots in a field, where each crop plot can only be visited by a given pair of entry/exit points (we have three different types, each having four cases), we study the corresponding Minimum Spanning Tree (MST) problem of such a planar set of axis-aligned unit squares. It turns out that this crop plot distance does not satisfy triangle inequality, even though the whole setup of the problem is geometric. Hence additional care must be taken. The main results of this paper are as follows: (1) we prove that computing the MST of a set $P$ of unit squares under the crop plot distance is NP-hard, (2) the MST of $P$ can be approximated with a factor-4 approximation.

Wed 30 SeptComputational Geometry
The gist
The team studied the problem of connecting crop plots in a field where each plot can only be entered and exited through certain points. They found that the usual distance rules don't apply here, making it tricky to find the shortest network connecting all plots. They proved that finding this minimal network is very difficult (NP-hard). However, they also developed a method to get a network that is at most four times longer than the shortest possible.
Open → 2610.00807v1

Greedy matching method analyzed for random points in space

Optimal Analysis of Greedy for Stochastic Online Euclidean Matching

Abstract: We study Greedy for online metric matching with $n$ servers and $n$ requests sampled independently and uniformly from $[0,1]^d$. Servers are available initially, and Greedy irrevocably matches each arriving request to its closest available server, incurring a cost of their distance. We prove that Greedy has competitive ratio $O(1)$ for every fixed $d\ne2$, and $Θ(\sqrt{\log n})$ for $d=2$. Previously, constant competitiveness was shown for $d = 1$ [BFP23], and no non-trivial results for this setting were known for higher dimensions. Our proof first analyzes Greedy on the flat torus and then transfers the estimates back to the cube.

Sun 20 SeptData Structures and Algorithms
The gist
Matching things quickly and well is hard when points appear randomly in space. This paper studies a simple greedy strategy that pairs each new point with the closest available spot. The authors show that this approach works consistently well in most dimensions except two, where its performance grows slowly with more points. This improves understanding of how well a basic method handles random spatial matching problems.
Open → 2609.23947v1