Shortest Paths on Convex Polyhedral Surfaces

TL;DR

This paper introduces improved data structures and algorithms for efficiently computing shortest paths on convex polyhedral surfaces, reducing preprocessing time and space while maintaining fast query times.

Contribution

It presents a new data structure with reduced preprocessing complexity for shortest path queries on convex polyhedra and an efficient algorithm for computing all shortest path edge sequences.

Findings

Achieves $O( ext{log} n)$ query time with $O(n^{6+ ext{epsilon}})$ preprocessing.

Reduces preprocessing for special case to $O(n^{5+ ext{epsilon}})$.

Develops an $O(n^{5+ ext{epsilon}})$ algorithm for shortest path edge sequences.

Abstract

Let $\mathcal{P}$ be the surface of a convex polyhedron with $n$ vertices. We consider the two-point shortest path query problem for $\mathcal{P}$: Constructing a data structure so that given any two query points $s$ and $t$ on $\mathcal{P}$, a shortest path from $s$ to $t$ on $\mathcal{P}$ can be computed efficiently. To achieve $O(\log n)$ query time (for computing the shortest path length), the previously best result uses $O(n^{8+\epsilon})$ preprocessing time and space [Aggarwal, Aronov, O'Rourke, and Schevon, SICOMP 1997], where $\epsilon$ is an arbitrarily small positive constant. In this paper, we present a new data structure of $O(n^{6+\epsilon})$ preprocessing time and space, with $O(\log n)$ query time. For a special case where one query point is required to lie on one of the edges of $\mathcal{P}$, the previously best work uses $O(n^{6+\epsilon})$ preprocessing time and space to achieve $O(\log n)$ query time. We improve the preprocessing time and space to $O(n^{5+\epsilon})$, with $O(\log n)$ query time. Furthermore, we present a new algorithm to compute the exact set of shortest path edge sequences of $\mathcal{P}$, which are known to be $\Theta(n^4)$ in number and have a total complexity of $\Theta(n^5)$ in the worst case. The previously best algorithm for the problem takes roughly $O(n^6\log n\log^*n)$ time, while our new algorithm runs in $O(n^{5+\epsilon})$ time.