🤖 AI Summary
This study addresses the problem of partitioning a polygon into the minimum number of strips of width at most 1, aligned with a given orthogonal direction, and producing a compact representation of the optimal partition. It introduces, for the first time in this domain, the Clarke–Cormack–Burkowski lattice-theoretic framework, modeling the problem via interval antichains and combining meet/join operations with dynamic programming to devise an input-sensitive optimal algorithm. For convex polygons, the approach achieves an O(log n)-time decision version and an O(h log(1 + n/h))-time reporting version, where h is the number of strips in the optimal solution. For both simple and self-overlapping polygons, it attains O(n log n) time complexity, while establishing matching lower bounds of Ω(n) and Ω(n log n), respectively, thereby yielding tight complexity characterizations for all three polygon classes.
📝 Abstract
We study a variant of a polygon partition problem, introduced by Chung, Iwama, Liao, and Ahn [ISAAC'25]. Given orthogonal unit vectors $\mathbf{u},\mathbf{v}\in \mathbb{R}^2$ and a polygon $P$ with $n$ vertices, we partition $P$ into connected pieces by cuts parallel to $\mathbf{v}$ such that each resulting subpolygon has width at most one in direction $\mathbf{u}$. We consider the value version, which asks for the minimum number of strips, and the reporting version, which outputs a compact encoding of the cuts in an optimal strip partition.
We give efficient algorithms and lower bounds for both versions on three classes of polygons of increasing generality: convex, simple, and self-overlapping. For convex polygons, we solve the value version in $O(\log n)$ time and the reporting version in $O\!\left(h \log\left(1 + \frac{n}{h}\right)\right)$ time, where $h$ is the width of $P$ in direction $\mathbf{u}$. We prove matching lower bounds in the decision-tree model, showing that the reporting algorithm is input-sensitive optimal with respect to $h$. For simple polygons, we present $O(n \log n)$-time, $O(n)$-space algorithms for both versions and prove an $Ω(n)$ lower bound. For self-overlapping polygons, we extend the approach for simple polygons to obtain $O(n \log n)$-time, $O(n)$-space algorithms for both versions, and we prove a matching $Ω(n \log n)$ lower bound in the algebraic computation-tree model via a reduction from the $δ$-closeness problem.
Our approach relies on a lattice-theoretic formulation of the problem. We represent strip partitions as antichains of intervals in the Clarke--Cormack--Burkowski lattice, originally developed for minimal-interval semantics in information retrieval. Within this lattice framework, we design a dynamic programming algorithm that uses the lattice operations of meet and join.