Computing Planar Convex Hulls with a Promise

TL;DR

This paper presents a sub-$O(n \,\log n)$ time algorithm for computing convex hulls under a specific promise that the hull points are sorted, and proves this promise is tight for faster algorithms.

Contribution

It introduces a deterministic $O(n \,\sqrt{\log n})$-time algorithm and an expected $O(n \log^{\varepsilon} n)$ randomized algorithm for convex hulls under a new promise, and shows this promise is tight.

Findings

Deterministic $O(n \sqrt{\log n})$-time convex hull algorithm under the promise.

Expected $O(n \log^{\varepsilon} n)$ randomized algorithm with the same promise.

Breaking the promise even slightly leads to an $\\Omega(n \log n)$ lower bound.

Abstract

Computing the convex hull of a planar $n$-point set $P$ is one of the most fundamental problems in computational geometry. It has an $\Omega(n \log n)$ lower bound in the algebraic computation tree model, and many convex hull algorithms match this bound. Classical results show that, under special input assumptions, sub-$O(n \log n)$ algorithms are possible. For instance, when the points are given in lexicographic or angular order, the convex hull can be computed in linear time. Even under the weaker assumption that the sequence of points corresponds to the ordered vertices of a simple polygonal chain, linear-time algorithms exist. This naturally raises the question: can the convex hull of a point set be computed in sub-$O(n \log n)$ time under weaker input assumptions? We answer this positively. Under the promise that the input sequence contains the convex hull as a subsequence, we give a deterministic $O(n \sqrt{\log n})$-time algorithm to compute the convex hull of $P$. With randomisation, we achieve expected running time $O(n \log^{\varepsilon} n)$ for any constant $\varepsilon > 0$. We find this surprising, as points not on the convex hull may behave adversarially toward our convex hull construction algorithm. Yet the promise that \emph{only} the hull points are sorted suffices for $o(n \log n)$-time algorithms. Finally, we show that this promise is tight: if it is even slightly broken, i.e., allowing just one hull point to appear out of order, we prove an adversarial $\Omega(n \log n)$-time lower bound. Consequently, the promise cannot be verified with fewer than $\Omega(n \log n)$ comparisons. This also negatively resolves an open problem of L\"{o}ffler and Raichel, who conjectured sub-$O(n \log n)$-time algorithms for computing the convex hull of a supersequence containing the hull as a subsequence.