Stabbing segments with rectilinear objects

TL;DR

This paper develops efficient algorithms to find all regions that contain exactly one endpoint of each segment in a set, for various rectilinear shapes like halfplanes, strips, quadrants, and rectangles.

Contribution

It introduces optimal or near-optimal algorithms for reporting all combinatorially different stabbers of specific rectilinear shapes.

Findings

Linear time algorithm for halfplanes

O(n log n) algorithms for strips, quadrants, and 3-sided rectangles

O(n^2 log n) algorithm for rectangles

Abstract

Given a set $S$ of $n$ line segments in the plane, we say that a region $\mathcal{R}\subseteq \mathbb{R}^2$ is a {\em stabber} for $S$ if $\mathcal{R}$ contains exactly one endpoint of each segment of $S$. In this paper we provide optimal or near-optimal algorithms for reporting all combinatorially different stabbers for several shapes of stabbers. Specifically, we consider the case in which the stabber can be described as the intersection of axis-parallel halfplanes (thus the stabbers are halfplanes, strips, quadrants, $3$-sided rectangles, or rectangles). The running times are $O(n)$ (for the halfplane case), $O(n\log n)$ (for strips, quadrants, and 3-sided rectangles), and $O(n^2 \log n)$ (for rectangles).

Figures

Tables

Table 1. Table 1: Worst-case running times of previous and new algorithms that, given a set of segments, report all combinatorially different stabbers of different shapes, containing exactly one endpoint from each segment. We omit previous results that only work for certain classes of segments (e.g., parallel segments).

Stabber	Running time	Reference
Horizontal line	$O\left(n\right)$	This paper
Line	$O\left(n\log n\right)$	Edelsbrunner et al. [21]
Horizontal strip	$O\left(n\log n\right)$	This paper
Quadrant	$O\left(n\log n\right)$	This paper
3-sided (axis-parallel) rectangle	$O\left(n\log n\right)$	This paper
Axis-parallel rectangle	$O\left(n^2\log n\right)$	This paper
Wedge	$O\left(n^3\log n\right)$	Claverol et al. [15]
Double-wedge	$O\left(n^4\log n\right)$	Claverol et al. [15]
Zigzag	$O\left(n^3\log n\right)$	Claverol et al. [15]
Circle	$O\left(n^2\right)$	Claverol et al. [17]

Full text

1 Introduction

Stabbing or transversal problems have been widely investigated in computational geometry and related areas. The general idea is to find a region with certain characteristics that intersects (or stabs) a collection of geometric objects in a particular way. This family of problems finds applications in multiple areas, such as automatic map generation [28], line simplification [23], regression analysis [5, 3], and even in bioinformatics, concretely in simplification of molecule chains for visualization, matching and efficient searching in molecule and protein databases [20].

A substantial amount of research in this area has focused on studying the problem of stabbing a collection of line segments. Several different criteria have been used to define what it means for a region to stab a set of segments: (i) the region must contain exactly one endpoint of each segment, (ii) the region must contain at least one endpoint of each segment, or (iii) the region must intersect all segments (but no restriction on the endpoints is given).

Most previous work on stabbers focuses on criteria (ii) or (iii), but in this paper we deal with criterion (i): we say that a region $\mathcal{R}\subseteq\mathbb{R}^{2}$ stabs a set of segments $S$ if $\mathcal{R}$ contains exactly one endpoint of each segment of $S$; see Figure 1(a). Concretely, we study the problem of computing all the combinatorially different stabbers of a given set of segments for some types of stabbing regions. Two stabbing regions are considered combinatorially different if and only if the sets of segment endpoints contained in each of them are different, otherwise they are said to be combinatorially equivalent. Note that under our definition of stabbing region, the segments can be seen as pair of points (the interior of the segment does not play any role); however, as we will see afterwards, it will be convenient to keep referring to them as segments.

Our interest in criterion (i) mainly comes from its differences with respect to the other two criteria. The existence of stabbers in our setting is not always guaranteed, whereas for criteria (ii)-(iii) it is usually easy to find some stabbing region (there are always trivial solutions); this makes our decision question interesting and non-trivial (see Fig. 1). Also, the study of stabbers that require regions to contain exactly one endpoint of each segment fits into the general framework of classification or separability problems because the stabbers classify endpoints (the ones inside the region and those outside). This is an interesting connection because classification problems arise in many diverse applications, see for instance [26].

1.1 Previous work

We begin discussing previous work on the stabbing model studied in this paper, i.e., criterion (i), and only later we review work on criteria (ii) and (iii).

Perhaps the simplest stabber one can consider is a halfplane, whose boundary is defined by a line. Hence, a stabbing halfplane is defined by its boundary: a line that intersects all segments (note that the complement of a stabbing halfplane is another stabbing halfplane, with the same boundary line). In this context, Edelsbrunner et al. [21] presented an $O(n\log n)$ time algorithm for solving the problem of constructing a representation of all combinatorially different stabbing lines (with any orientation) of a given set of $n$ segments. Moreover, they also gave an $\Omega(n\log n)$ lower bound for the problem. However, the lower bound from [21] does not apply to the decision problem (i.e., determining whether or not there exists a line stabber for a set of segments). Afterwards, Avis et al. [8] gave an $\Omega(n\log n)$ lower bound that holds even for the decision problem in the fixed order algebraic decision tree model.

When no stabbing halfplane exists, it is natural to ask for a stabbing wedge (the stabbing region defined by the intersection of two halfplanes). Claverol et al. [14, 15] studied the problem of reporting all combinatorially different stabbing wedges of $S$. The time and space complexities of their algorithm depend on two parameters of $S$, which in the worst case result in $O(n^{3}\log n)$ time and $O(n^{2})$ space. The authors of [15] also studied some other stabbers such as double-wedges and zigzags. The problem of computing stabbing circles of a set $S$ of $n$ line segments in the plane has been studied very recently by Claverol et al. [17], obtaining the following results: (i) a representation of all the combinatorially different stabbing circles for $S$ can be computed in $O(n^{2})$ time and space; and (ii) one can report all stabbing circles for a set of parallel segments in $O(n\log^{2}n)$ time and $O(n)$ space.

Many of the problems studied for criteria (i) (and (ii)) can be formulated in terms of color-spanning objects. In this case, the input is a set of $n$ colored points, with $c$ colors, and the goal is to find an object (rectangle, circle, etc.) that contains at least (or exactly) $k$ points of each color. Our setting, with criterion (i), is the particular case in which $c=n/2$ and we want to contain exactly one point of each color class. Barba et al. [10] considered several problems related to color-spanning objects for criterion (i). In particular, they present algorithms that can compute disks, squares, and axis-aligned rectangles that contain exactly one element of each of the $c$ color classes in $O(n^{2}c)$ time.

In a very recent paper, Arkin et al. [6] studied the computation of minimum length separating cycles for a set of pairs of points. The problem can be seen as that of finding a polygonal stabber of minimum perimeter for a set of line segments. Since the problem is NP-hard, Arkin et al. [6] focused on approximation algorithms for several special cases.

1.1.1 Other stabbing criteria

There is plenty of related work for the two other criteria mentioned before: (ii) containing at least one endpoint, or (iii) intersecting each segment. In the following we briefly mention some of the most relevant papers for these criteria.

Most previous work for criteria (ii) and (iii) has focused on objects in two dimensions. Atallah and Bajaj [7] considered the problem of determining a stabbing line for a collection of objects in the plane. Bhattacharya et al. [11] studied the computation of the shortest stabbing segment of a collection of segments (and lines) with criterion (iii). Arkin et al. [5] considered the problem of computing convex stabbers for sets of segments in the plane, also for criterion (iii). Several types of stabbers have been studied for criterion (ii) in the context of color-spanning objects, namely strips, axis-parallel rectangles [1, 18], and circles [2]; all of them can be computed in roughly $O(n^{2}\log c)$ time, for $c$ the number of different colors. Several papers [32, 25, 34, 12, 30, 31, 19] have studied problem variants with the goal of optimizing perimeter or area of the convex polygon stabbing a set of segments, using criteria (ii) and (iii).

Some three-dimensional variants have also been studied, most notably the problem of computing stabbers or transversals of a set of segments in 3D [9, 13, 22] and a few stabbing problems for convex polyhedra [9, 27, 33] .

Very recently, Arkin et al. [4] studied other related problems in this setting, mainly focused on minimizing the number objects (e.g., unit squares) needed to contain exactly one point from each color.

Finally, we mention that there are other families of related problems about intersections and transversals, although usually formulated in much more general settings, in work about geometric transversal theory. We refer to [24] for a survey on the topic.

Contributions

In this paper we consider stabbers that can be described as the intersection of axis-parallel (i.e., horizontal or vertical) halfplanes. Thus, the shapes we consider are halfplanes, strips, quadrants, $3$-sided rectangles, and rectangles. This scenario, more restrictive than the ones previously studied for this definition of stabber [15, 21, 14], allows us to exploit the geometric structure of the possible stabbers to obtain much faster algorithms.

In Section 2 we study the case in which the stabber is formed by one or two halfplanes (that is, halfplanes, strips and wedges). For that purpose, we introduce a general approach that partitions the plane into three regions: a red region that must be contained in any stabber, a blue region that must be avoided by any stabber, and a gray region for which we do not have enough information yet. The algorithms are based on iteratively classifying segments and updating the boundaries of these regions, a process that we call cascading. In Section 3 we extend this approach to $3$-sided rectangles. To analyze the running time of our algorithm, we show that the maximum number of combinatorially different stabbers of this type is only $\Theta(n)$. All algorithms in Sections 2 and 3 are asymptotically optimal. Finally, in Section 4, we use the algorithm for 3-sided rectangles to find all different stabbing axis-parallel rectangles. Table 1 summarizes the results presented in this paper, together with the previous results for criterion (i) that put no constraints on the input segments.

To the best of our knowledge, the stabbing problems studied in this paper had not been considered before, except for rectangles, which are a particular case of the more general problem studied in [10]. The algorithm presented in Section 4 (for axis-aligned rectangular stabbers) improves the result of [10] for the particular case in which $c=n/2$ and one looks for an axis-aligned color spanning rectangle. Our algorithm is almost a linear factor faster, and also allows to report all possible solutions (whereas their algorithm only reports one).

1.2 Preliminaries

The input to our problems consists of a set $S$ of $n$ segments in $\mathbb{R}^{2}$. For simplicity in the exposition, we assume that there is no horizontal or vertical segment in $S$, and that all segments have non-zero length. The modifications needed to make our algorithms handle these special cases are straightforward, albeit rather tedious.

Let $s=\{p,q\}$ be a segment of endpoints $p,q$; recall that in this paper a segment can be seen as a pair of points, and so we will say indistinctly endpoints of segments of $S$ and points of $S$. For distinguishing the upper and the lower endpoints of $s$, say $p$ and $q$ respectively, we use $s=(p,q)$. Given a point $p\in\mathbb{R}^{2}$, we write $x(p)$ (resp. $y(p)$) for its $x$- (resp. $y$-) coordinate. Let $y_{b}=\max_{(p,q)\in S}\{y({q})\}$ and $y_{t}=\min_{(p,q)\in S}\{y(p)\}$; these values correspond to the $y$-coordinates of the highest bottom endpoint and the lowest top endpoint, respectively, of the segments of $S$. Let $s_{b}=(p_{b},q_{b})$ and $s_{t}=(p_{t},q_{t})$ where $y({q}_{b})=y_{b}$ and $y(p_{t})=y_{t}$.

We say that a point is red if it is contained in the stabbing region $\mathcal{R}$, or blue otherwise. Note that we consider $\mathcal{R}$ a closed region, thus points on its boundary are considered red. In addition, throughout this paper we assume that all solutions (i.e., red stabbing regions) are represented by a minimal number of red points on the region boundary: one point for halfplanes, two points for strips and quadrants, three points for 3-rectangles, and four points for rectangles.

We say that a stabbing region $\mathcal{R}$ is trivial if there is a stabbing region $\mathcal{R}^{\prime}$ described as the intersection of fewer halfplanes that is combinatorially equivalent to $\mathcal{R}$ (i.e., gives the same classification of the endpoints of the segments in $S$). In principle, our algorithms report all combinatorially different solutions, trivial and non-trivial. However, we note that it is very easy to detect when a solution is trivial (and thus, if needed we can avoid reporting those). Details of this are given in the proof of Theorem 2.2 for strips, but the same approach extends to all the other stabbers considered.

Finally, we note that even though we present our algorithms for stabbers defined by axis-parallel halfplanes, they extend to any two fixed orientations by making an appropriate affine transformation.

2 Stabbing with one or two halfplanes

In this section we look for stabbers that can be described as the intersection of at most two halfplanes. That is, our goal is to find halfplanes, strips, or quadrants that contain exactly one endpoint from each segment. Recall that such stabbing objects do not always exist.

2.1 Stabbing halfplane

As a warm-up, we give a simple algorithm for determining if a stabbing horizontal halfplane exists. That is, a horizontal line such that one of the (closed) halfplanes defined by the line contains exactly one endpoint from each segment. Thus, we are effectively looking for a horizontal line that intersects all the segments (such a line can define up to two complementary stabbers).

Although the algorithm is straightforward, we explain it for completeness. As we are dealing with horizontal stabbers, the problem becomes essentially one-dimensional, and it will ease our presentation to state the problem in that way.

All segments can be projected onto the $y$-axis, becoming intervals. Considering the set $\overline{S}=\{\overline{s}\,|\,s\in S\}$ of projected segments, the question is simply whether all the intervals in $\overline{S}$ have a point in common. Then, any horizontal line $y:=u$ stabbing $S$ must have its $y$-coordinate between the two values $y_{b}$ and $y_{t}$, namely $y_{b}\leq u\leq y_{t}$. Therefore such a line exists if and only if $y_{b}\leq y_{t}$. Moreover, whenever this condition happens, both the upper and lower halfplanes will be stabbing halfplanes (and any other horizontal halfplane will be combinatorially equivalent to one of the two). This simple observation directly leads to a straightforward linear-time algorithm.

Observation 1

We can find all the two axis-aligned stabbing halfplanes of a set $S$ of $n$ segments (or determine that none exists) in $O(n)$ time.

2.2 Stabbing strips

We now consider the case in which the stabbing region is a horizontal strip. Note that the existence of stabbing halfplanes directly implies the existence of stabbing strips, but the reverse is not true.

As in Section 2.1, we can ignore the $x$-coordinates of the endpoints, project the points onto the $y$-axis, and work with the set $\overline{S}$ instead. The endpoints of the classified segments can be seen in the projection onto the $y$-axis as a set of blue and red points. It follows that there is a separating horizontal strip for them if and only if the red points appear contiguously on the $y$-axis. More precisely, the points must appear on the $y$-axis in three contiguous groups, from top to bottom, first a blue group, then a red group, and then another blue group. We refer to the two groups of blue points as the top and bottom blue points, respectively. We denote the intervals of the $y$-axis spanned by them by $B_{t}$ and $B_{b}$, respectively. The interval of the $y$-axis spanned by the group of red points is denoted by $R$. Moreover, since all points above $B_{t}$ and below $B_{b}$ must be necessarily blue, we extend $B_{t}$ and $B_{b}$ from $+\infty$ and until $-\infty$, respectively. In this way the $y$-axis is partitioned into two blue intervals, one red interval, and two intervals separating them that we will consider of color gray. See Fig. 2(a).

Our algorithm relies on the following two observations.

Observation 2

Let $s_{i}=(p_{i},q_{i})$ and $s_{j}=(p_{j},q_{j})$ be two segments of $S$ such that the projected segment $\overline{s}_{i}$ is above the projected segment $\overline{s}_{j}$ (in particular, this implies that $\overline{s}_{i}$ and $\overline{s}_{j}$ are disjoint). Then, any horizontal stabbing strip for $S$ must contain $q_{i}$ and $p_{j}$.

Proof

It follows from the fact that any strip that contains $q_{i}$ (and some endpoint of $s_{j}$) will also contain $p_{i}$. Similarly, strips that contain $q_{j}$ (and endpoints of $s_{i}$) will contain $q_{i}$. Since a strip cannot contain both endpoints of a segment of $S$, the claim follows.

Observation 3

Any non-trivial horizontal stabbing strip $\mathcal{R}$ for $S$ contains points $q_{b}$ and $p_{t}$.

Proof

If $y_{b}>y_{t}$, we can use Observation 2 to prove our statement. Thus, it remains to consider the case in which $y_{b}<y_{t}$.

First observe that $\mathcal{R}$ must contain line $y=y_{b}$ or $y=y_{t}$. Indeed, if it contains neither of the two lines, the stabber is either in $(i)$ the halfplane $y>y_{t}$, $(ii)$ the halfplane $y<y_{b}$, or $(iii)$ in the strip $y_{b}<y<y_{t}$. However, in case $(i)$ $\mathcal{R}$ does not contain an endpoint of $s_{t}$. Similarly, any stabber in $(ii)$ cannot contain endpoints of $s_{b}$, and stabbers in $(iii)$ cannot contain endpoints of neither segment, a contradiction.

Without loss of generality, we can assume that $\mathcal{R}$ contains the line $y=y_{t}$ (and thus, it contains $p_{t}$). Assume, for the sake of contradiction, that $\mathcal{R}$ does not contain $q_{b}$. By definition of $s_{b}$, no bottom endpoint of a segment of $S$ can be in $\mathcal{R}$ (since they are below $s_{b}$). In particular, $\mathcal{R}$ must contain all upper endpoints of the segments of $S$, and thus $\mathcal{R}$ is equivalent to the halfplane $y\geq y_{t}$. However, this contradicts with the fact that $\mathcal{R}$ is a non-trivial stabber.

With the previous observations in place, we can present our algorithm. First we give an intuitive idea in rather general terms because it will also be used in the upcoming sections.

The algorithm starts by classifying a few segments of $S$ using some geometric observations (in the case of strips, Observation 3). As soon as some points are classified, the plane can be partitioned into three regions: the red region (a portion of the plane that must be contained by any stabber), the blue region (a portion of the plane that cannot be contained in any stabber) and the gray region (the complement of the two other regions: regions of the plane for which we still do not have enough information yet). If a segment of $S$ has an endpoint in the blue region it can be classified as blue (similarly if an endpoint is in the red region). The other endpoint of the segment must have the opposite color. This coloring may enlarge either the red or blue regions, which may further allow to classify other segments of $S$. This results in an iterative process that we call cascading procedure. We continue in this fashion until either a contradiction is found (that is, the red and blue regions overlap), or all segments of $S$ have been classified (and hence a stabber has been found).

At any instant of time $S$ is partitioned into three sets $C$, $W$, and $U$. A segment is in $C$ if it has been already classified, in $W$ if it is waiting for being classified (there is enough information to classify it, but it has not been done yet), or in $U$ if its classification is still unknown. The algorithm is initialized with $C=W=\emptyset$, and $U=S$.

Regions

In addition to the three sets of segments $C$, $W$, and $U$, the algorithm maintains red and blue candidate regions that are guaranteed to be contained or avoided in any solution, respectively. When we are looking for a horizontal strip, these regions will also be horizontal strips. Thus, it suffices to maintain the projection of the regions on the $y$-axis. The blue and red regions are represented by three intervals $B_{t}$, $R$, and $B_{b}$. We define the blue region as $B_{t}\cup B_{b}$ and the red region as $R$. The complement of the union of the blue and red regions is called the gray region. Note that the gray region, like the blue one, consists of two disjoint components. During the execution of the algorithm the regions will become updated as new segments become classified.

The algorithm starts by computing $s_{b}$ and $s_{t}$. If a stabbing halfplane exists (i.e., $y_{b}\leq y_{t}$), then the only two (trivial) stabbing strips can be reported as described above. Otherwise, Observation 3 indicates how $s_{b}$ and $s_{t}$ should be classified: $q_{b}$ and $p_{t}$ as red, and $p_{b}$ and $q_{t}$ as blue. See Fig. 2(a). Thus, they can be moved from $U$ to $W$.

Cascading procedure

The procedure iteratively classifies segments in $W$ based on the red and blue regions. This is an iterative process in the sense that the classification of one segment can make the blue or red region grow, making other segments move from $U$ to $W$.

In the iterative phase, the algorithm picks a segment $s\in W$ (if any), assigns the corresponding colors to its endpoints, and moves $s$ from $W$ to $C$. If a newly assigned endpoint lies outside its corresponding zone, the red or blue area must grow to contain that point. Note that after the red or blue region grows, other segments can change from $U$ to $W$. As mentioned above, this process continues until either: (i) a contradiction is found (the red region is forced to overlap with the blue region), or (ii) set $W$ becomes empty. See Fig. 2(b) for an example.

Lemma 1

If the cascading procedure finishes without finding a contradiction, each remaining segment in $U$ has an endpoint in each of the connected components of the gray region.

Proof

By definition, when the cascading procedure finishes, all segments still in $U$ must have both endpoints in the gray region. Assume, for the sake of contradiction, that there exists a segment $s=(p,q)\in U$ with both endpoints in the same gray component, say, the lower one. Recall that, by construction, the red region $R$ contains the interval $[y_{b},y_{t}]$. In particular, we have $y(p)<y_{t}$, giving a contradiction with the definition of $y_{t}$.

Corollary 1

A horizontal stabbing strip for $S$ exists if and only if the cascading procedure finishes without finding a contradiction.

Proof

From the above observations, it is clear that if the cascading procedure finds a contradiction, then there will be no solution. Likewise, if no contradiction is found, we can find a solution by extending the bottom boundary of $B_{t}$ until it covers the upper gray component and extending the bottom boundary of $R$ until it covers the lower gray component (or vice versa).

Theorem 2.1

Determining whether there exists a stabbing strip for a set $S$ of $n$ segments can be done in $O(n\log n)$ time and $O(n)$ space.

Proof

The correctness follows from the previous observations, thus we focus on the running time. In order to implement the cascading procedure efficiently, we must be able to quickly find if there is a segment that has an endpoint in $B_{t}$, $B_{b}$, or $R$. Recall that the red and blue regions are simply intervals. Thus, the queries can be done by maintaining a balanced binary tree (sorted by $y$-coordinate) with the endpoints of all unclassified segments. In this way, a segment with an endpoint in, say, $B_{t}$ can be found in $O(\log n)$ time by querying the tree with the endpoints of $B_{t}$. Every time an endpoint inside $B_{t}$ is found, it is removed from the tree, and moved into $W$. When classifying a segment, the limits of $B_{t}$, $B_{b}$, or $R$ must also be updated accordingly. Since these intervals have constant complexity they can be updated in constant time. Further observe that no interval is classified more than once, which in particular implies that the total time for the cascading operation is bounded by $O(n\log n)$.

Reporting all horizontal stabbing strips

The above algorithm can be modified to report all combinatorially different horizontal stabbing strips without increasing the asymptotic running time.

We execute the algorithm as usual until the cascading procedure finishes. Let $U=\{s_{1},\ldots,s_{k}\}$ and let $\tau$ be the index of the segment of $U$ whose upper endpoint is lowest (i.e., for any index $i$ such that $s_{i}=(p_{i},q_{i})\in U$, it holds that $y(p_{i})\geq y(p_{\tau})$). Likewise, we define $\beta$ as the index whose lower endpoint is highest. Any stabbing strip will either contain: (i) all points in the upper component of the gray region, (ii) all points in the lower component of the gray region, or (iii) both $p_{\tau}$ and $q_{\beta}$. The first two can be reported in constant time, and for the third case, it suffices to classify the two segments, cascade, and repeat the previous steps.

Theorem 2.2

All combinatorially different stabbing strips for a set $S$ of $n$ segments can be computed in $O(n\log n)$ time.

Proof

The only new operations that the algorithm introduces are searching for the indices $\tau$ and $\beta$, and executing further cascading procedures. Since we keep the elements of $U$ in a balanced binary tree, the former operation can be done in logarithmic time. As in the decision version, each segment can only trigger one cascade operation, hence the total running time is also bounded by $O(n\log n)$.

Finally, a brief remark about detecting trivial stabbers. Recall that a stabber is trivial if there is a simpler one (i.e., defined by less halfplanes) that classifies points in the same manner. For example, for the case of strips, a stabbing strip is trivial if there exits a stabbing halfplane that gives the same classification. It follows that a stabber is trivial if and only if when extending one of its sides to infinity, the region that is “swept” is empty of points of $S$. This situation can be checked in $O(\log n)$ time using an orthogonal range searching data structure (e.g., [29]). Since our stabbers are defined by up to four halfplanes, four queries are enough to determine if a given stabber is trivial. This additional verification process adds a cost of $O(k\log n)$, where $k$ is the number of stabbers found. Since we know that $k\in O(n)$, this process does not increase the asymptotic running time of our algorithms.

Next we show that this running time is asymptotically optimal for computing the narrowest strip, and thus also for reporting all of them, at least under the model assumed in this paper.

Theorem 2.3

The problem of computing the narrowest stabbing strip for a set $S$ of $n$ segments is $\Omega(n\log n)$ in the algebraic decision tree model.

Proof

We present a reduction from the Maximum Gap problem, which is well-known to have an $\Omega(n\log n)$ lower bound in the algebraic decision tree model. The input to Maximum Gap is a set of $n$ real numbers $X=\{x_{1},x_{2},\dots,x_{n}\}$, which we can assume to be positive. The output is the maximum difference between two numbers in $X$ that are consecutive in sorted order. Next we show that any Maximum Gap instance can be solved with an algorithm that computes the vertical stabbing strip of minimum width for a set of $n$ segments.

Given the set of numbers $X$, we build a set of horizontal segments $S$ as follows. Let $x_{M}$ be the largest number in $X$. For each $x_{i}\in X$, we add a segment $s_{i}$ whose endpoints have $x$-coordinates $-x_{M}+x_{i}-1$ and $x_{i}$. Since we are interested in vertical strips, the $y$-coordinates of the segments are irrelevant, so for simplicity the $y$-coordinate of the endpoints of $s_{i}$ is set to $i$, that is, $s_{i}=\{(-x_{M}+x_{i}-1,i),(x_{i},i)\}$. Refer to Figure 3. Finally, to avoid having a trivial stabbing strip (i.e., a stabbing halfplane), we add two extra segments $\{(\varepsilon,0),(x_{M},0)\}$ and $\{(-x_{M},0),(-\varepsilon,0)\}$ (for some arbitrarily small $\varepsilon>0$).

Recall that a stabbing strip is given by the two red segment endpoints through which the (vertical) bounding lines of the strip go. By Observation 3, any stabbing strip of $S$ must have its left defining line through a negative $x$-coordinate and its right defining line through a positive $x$-coordinate. Consider a stabbing strip with right defining line $x=x_{i}$, and let $x_{j}$ be the $x$-coordinate of the next consecutive endpoint in $S$. Then the strip contains all right endpoints in $[0,x_{i}]$, and misses all those in $[x_{j},x_{M}]$. Since the right endpoint of $s_{j}$ is not contained in the strip, its left endpoint must be $(-x_{M}+x_{j}-1,j)$. By construction, left endpoints appear, from left to right, in the same order as right endpoints, thus the strip cannot contain any left endpoint to the left of $(-x_{M}+x_{j}-1,j)$, because the next left endpoint corresponds to $s_{i}$, which is already stabbed. Therefore its left defining line must go through $(-x_{M}+x_{j}-1,j)$.

Thus, for each $x_{i}\in X$ there is exactly one vertical stabbing strip associated with it. The boundary of such strip is given by two lines of the form $x=x_{i}$ and $x=-x_{M}-1+x_{j}$, and in particular it has width $x_{M}+1-(x_{j}-x_{i})$. Note that $(x_{j}-x_{i})$ is the gap between $x_{i}$ and the next consecutive number in $X$, $x_{j}$. It follows that a strip that has minimum width maximizes the gap between its associated endpoint and the next consecutive number in $X$, thus corresponds to the maximum gap in $X$.

If we assume that each strip is described by the endpoints from $S$ on each boundary line, then one can identify the narrowest strip in $O(n)$ time, and thus can also find the maximum gap in $X$ within the same running time.

Corollary 2

The problem of computing all combinatorially different stabbing strips for a set $S$ of $n$ segments, assuming that each strip is described by one point from $S$ on each boundary line, is $\Omega(n\log n)$ in the algebraic decision tree model.

Note that given that strips are particular cases of 3-rectangles and rectangles, the previous lower bound also applies to the problems in Sections 3 and 4.

2.3 Stabbing quadrants

We now extend the cascading approach to stabbing quadrants (i.e., a wedge formed by a horizontal and a vertical ray from a common point, the apex of the quadrant). There are four types of quadrants. Without loss of generality, we concentrate on the bottom-right type. Throughout this section, the term quadrant refers to a bottom-right quadrant. Other types can be handled analogously.

For a segment $s=\{p,q\}$, let $Q(s)$ denote its bottom-right quadrant; that is, the quadrant with apex at $(\max\{x(p),x(q)\},\min\{y(p),y(q)\})$. See Fig. 4(a).

Observation 4

Any quadrant classifying a segment $s$ must contain $Q(s)$.

Given the set $S$ of segments, the bottom-right quadrant of $S$, denoted by $Q(S)$, is the (inclusion-wise) smallest quadrant that contains $\cup_{s\in S}Q(s)$; see Fig. 4(b).

We now need the equivalent of Observation 3 to create the initial partition of the plane into red, blue, and gray regions.

Corollary 3

Any stabbing quadrant of $S$ must contain $Q(S)$.

Regions

The partition is as follows: the red region $R$ is always defined as the inclusionwise smallest quadrant that contains $Q(S)$ and all classified points. At any point during the execution of the algorithm, let $a=(x_{R},y_{R})$ denote the apex of $R$. Any blue point $b$ of a classified segment forbids the stabber to include $b$ or any point above and to the left of $b$ (i.e., in the top-left quadrant of $b$). Moreover, if $b$ satisfies $y(b)\leq y_{R}$ or $x(b)\geq x_{R}$ a whole halfplane will be forbidden (or, equivalently, blue). Thus, the union of the boundary of such blue regions forms a staircase polygonal line (see Fig. 4(c)). Initially, we take the blue region defined by a staircase with a single point at $(-\infty,\infty)$. We say that a point $p=(x,y)$ is in the gray region if it is not in a red or blue region, and satisfies either $x>x_{R}$ or $y<y_{R}$ (see Fig. 4(c)). As before, observe that the gray region is the union of two connected components (which we call right and down components). Note that, in this case, there are regions in the plane (which we call white) that do not belong to either red, blue, or gray regions. However, our first observation is that no endpoint of an unclassified segment can lie in the white region.

Observation 5

A segment $s\in S$ containing an endpoint in the white region must contain its other endpoint in the red region.

Proof

This fact follows from the definition of $Q(s)$: assume that there exists a segment $s\in S$ that has an endpoint in the white region and an endpoint in the right gray component. In particular, the $y$-coordinate of both endpoints is larger than $y_{R}$. Thus, the quadrant $Q(s)$ is not contained in $R$. However, recall that, by construction, we have $Q(s)\subseteq Q(S)\subseteq R$; obtaining a contradiction. Similar contradictions are found when the other endpoint of $s$ is in the other gray component, or in the white or blue regions.

Initially we classify all segments that have one endpoint inside $Q(S)$ in $W$ (and all the rest in $U$). As before, we apply the cascading procedure until we find a contradiction (in which case we conclude that a stabbing quadrant does not exist), or set $W$ eventually becomes empty. In this case we have a very strong characterization of the remaining unclassified segments.

Lemma 2

If the cascading procedure finishes without finding a contradiction, each remaining segment in $U$ has an endpoint in each of the gray components.

Proof

As with the strip case, the cascading procedure cannot finish if a segment in $U$ has an endpoint in either a red or a blue region. As argued in the proof of Observation 5, if both endpoints lie in the same gray component, quadrant $Q(s)$ is not contained in $R$, giving a contradiction.

Thus, if no contradiction is found we can extend $R$ until it contains one of the two gray components to obtain a stabber. This can be done because, by construction, each of the connected components of the gray region forms a bottomless rectangle (i.e, the intersection of three axis aligned halfplanes) that shares a corner with the apex of $R$.

As in the strip case, we can use the following approach to report all combinatorially different quadrants in an analogous fashion to Theorem 2.1: any stabbing quadrant will either completely contain one of the two gray components, or it will contain at least a segment of each of the two components.

Theorem 2.4

All the combinatorially different stabbing quadrants for a set $S$ of $n$ segments can be computed in $O(n\log n)$ time.

Proof

The proof of correctness is analogous to the strip case, thus we argue about the running time. The red and gray regions have constant complexity, and so they can be updated in constant time. The boundary of the blue region can be determined by $\Omega(n)$ points. However, notice that the points in the staircase are sorted in both the $x$-coordinates and the $y$-coordinates. Thus, we can insert a point in the blue region in $O(\log n)$ time if the points in the blue region are stored in a sorted fashion. Once we have inserted a new point, we check if this increase makes the red and blue regions intersect. Since we only need to compare the upper left quadrant defined by the new point with the red region, this can be done in constant time. Overall, we can update the red, blue and gray regions in $O(\log n)$ time.

Now we need an efficient method to update the segments in $W$ whenever the red or blue region changes. For that purpose we can use any data structure suitable for range searching with a quadrant. For example, one based on priority search trees [29] will suffice: given a bottomless rectangular query region, after $O(n\log n)$ preprocessing time and using $O(n)$ space, we can report in $O(\log n+k)$ time all segments containing an endpoint in the query region (or report that the region is empty), where $k$ is the number of segments within that region. Note that the structure is dynamic and can handle both deletions and insertions in $O(\log n)$ time.

Whenever a point is colored, its corresponding region is increased with a rectangular area (which may degenerate to a halfplane or bottomless rectangle). Thus, we can find the segments that contain at least one endpoint in the new segments with a rectangular range searching query. Each time we report the segment, we insert it into $W$, delete it from $U$ (and from the range searching data structure, so it is not reported again). Thus, all queries will be computed in total $O(n\log n)$ time and $O(n)$ space.

We can report all stabbing quadrants using the same approach as in the strip case: apply the cascading procedure until no more points remain in $W$, report the two stabbers that completely contain one of the gray components, or classify the segments in both components whose endpoints are closest to the red region, and further apply the cascading procedure.

Similarly to the case of stabbing strips, we can show that our algorithm is asymptotically optimal if regions have to be represented by endpoints on the boundary.

Theorem 2.5

The problem of computing all combinatorially different stabbing quadrants for a set $S$ of $n$ segments, assuming that each quadrant is described by one endpoint from $S$ on each boundary line, is $\Omega(n\log n)$ in the algebraic decision tree model.

Proof

The result is obtained by using a similar construction to the one used for Theorem 2.3 (see Fig. 3), with two simple modifications.

The first one is making all horizontal segments collinear, placing all of them on the $x$-axis. (This is done to simplify the arguments below, but larger distances between consecutive segments also work as long as they are small enough.)

The second one is rotating the coordinate system counterclockwise by $45^{\circ}$. In this way, there is a 1-to-1 correspondence between stabbing strips in the construction of Theorem 2.3 and stabbing quadrants in the modified version. However, since quadrants are unbounded in two directions, the concept of narrowest strip does not naturally extend to quadrants. Instead, we look at the width of the gray regions induced.

Recall that for quadrants the gray region has two connected components, and each one is described as the intersection of three quadrilaterals. More importantly, in the problem instance we construct, both regions will have the same width.

Specifically, if the upper boundary of the red region has an endpoint of $s_{i}$, we know that the endpoint in the associated blue region must be from $s_{j}$, where $j$ is the index of the value that goes after $i$ in $X$. Since we rotated the endpoints $45^{\circ}$, the width of the gray region will be equal to $1/\sqrt{2}$ times the difference between $x_{i}$ and $x_{j}$. Therefore the stabbing quadrant maximizing the width of its gray regions gives the maximum gap in $X$.

Finally, note that if one is given all combinatorially different stabbing quadrants for $S$, assuming that each of them is described by one endpoint from $S$ on each boundary line, then the one with widest gray regions can be identified in $O(n)$ time. The reduction follows.

3 Stabbing with three halfplanes

We now consider the case in which the stabber is defined as the intersection of three halfplanes. As in the quadrant case, it suffices to consider those of fixed orientation. Thus, throughout this section, a $3$-rectangle refers to a rectangle that is missing the lower boundary edge, and that extends infinitely towards the negative $y$-axis (also called bottomless rectangle). As in the previous cases, we solve the problem by partitioning the plane into red-blue-gray regions. However, in this case the algorithm will need an additional sweeping phase.

3.1 Number of different stabbing 3-rectangles

First we analyze the number of combinatorially different stabbing 3-rectangles that a set $S$ of $n$ segments can have. This analysis will lead to an efficient algorithm to compute them.

We start by defining a region that must be included in any stabbing $3$-rectangle. Recall that $s_{b}$ is the segment of $S$ with highest bottom endpoint, and $q_{b}$ is its bottom endpoint. Analogously, we define $s_{r}$ and $s_{\ell}$ as the segments with leftmost right endpoint and rightmost left endpoint, respectively. Let $p_{\ell}$ be the left endpoint of $s_{\ell}$ and let $p_{r}$ be the right endpoint of $s_{r}$. See Fig. 6(a). Finally, we define lines $L_{\ell}$, $L_{r}$ as the vertical lines passing through $p_{\ell}$ and $p_{r}$, respectively. Analogously, $L_{b}$ is the horizontal line passing through $q_{b}$.

Lemma 3

Any non-trivial stabbing $3$-rectangle $\mathcal{R}$ for $S$ must contain the intersection points of lines $L_{\ell}$, $L_{r}$ and $L_{b}$.

Proof

This proof is the analogous to that of Observation 3 but for 3-rectangles. First we prove that $\mathcal{R}$ must contain some point of $L_{b}$. Indeed, recall that $\mathcal{R}$ is a $3$-rectangle, hence if it has empty intersection with $L_{b}$, then it must be contained in the lower halfplane defined by $L_{b}$. In particular, it cannot contain any endpoint of $s_{b}$, reaching a contradiction.

Now, we distinguish between two cases depending on the respective locations of $p_{\ell}$ and $p_{r}$. First consider the case in which $x(p_{r})\leq x(p_{\ell})$. As in Observation 3, we can show that $\mathcal{R}$ must contain points of both $L_{\ell}$ and $L_{r}$. Otherwise, it would not contain an endpoint of either $s_{\ell}$ or $s_{r}$, respectively. That is, $\mathcal{R}$ must intersect the three lines $L_{b}$, $L_{\ell}$, and $L_{r}$. Moreover, since $\mathcal{R}$ is a 3-rectangle, it must contain the intersection points of the three lines.

It remains to consider the case in which $x(p_{r})>x(p_{\ell})$. Recall that in this case two trivial vertical halfplane stabbers exist (halfplanes $x\leq x(p_{\ell})$ and $x\geq x(p_{r})$). As in Observation 3, we show that $\mathcal{R}$ cannot avoid both $L_{r}$ and $L_{\ell}$: if it would have empty intersection with both lines, then it would be completely to the right, left, or in between these lines. Hence it would avoid $s_{r}$, $s_{\ell}$ or both $s_{r}$ and $s_{\ell}$, a contradiction. Thus, $\mathcal{R}$ must have nonempty intersection with either $L_{r}$ or $L_{\ell}$. We claim that if it intersects with exactly one of them, then $\mathcal{R}$ contains the same points of $S$ as one of the two trivial halfplane stabbers. Indeed, assume for the sake of contradiction that $\mathcal{R}$ intersects with $L_{\ell}$ but has empty intersection with $L_{r}$. In this case, $\mathcal{R}$ cannot contain any point in the right halfplane of $L_{r}$, see Fig. 6(b). By definition of $s_{\ell}$ and $s_{r}$, each segment of $S$ must contain an endpoint on or to the right of $L_{r}$ (none of which can be contained in $\mathcal{R}$), and another endpoint on or to the left of $L_{\ell}$. In particular, if $\mathcal{R}$ does not intersect with $L_{r}$, it must contain all endpoints on or to the left of $L_{\ell}$, and is combinatorially equivalent to the trivial halfplane stabber $x\leq x(p_{\ell})$. The case in which $\mathcal{R}$ intersects with $L_{r}$ and avoids $L_{\ell}$ is analogous.

Therefore, we conclude that $\mathcal{R}$ must intersect at least one point from each of $L_{b}$, $L_{\ell}$, and $L_{r}$, and thus it must contain the intersection points of the three lines.

The result above gives a way to initialize the red region (as the region determined by lines $L_{b}$, $L_{\ell}$, and $L_{r}$) to start the usual cascading procedure (whereas the blue region is initialized as empty). Segments with an endpoint in the red region are placed in $W$ (note that it may be that no such segment exists), and the usual cascading procedure is executed. If no contradiction is found, the classified segments define a red and a blue region that must be included or avoided in any solution, respectively. Specifically, the red region is the inclusionwise smallest 3-rectangle that contains all points classified as red (this region must contain at least the intersection points of Lemma 3). The blue region is the set of points whose inclusion would force a 3-rectangle to contain some point that has already been classified as blue. As usual, the area that is neither red nor blue is the gray region. Once the cascading procedure has finished, all remaining unclassified segments must have both of their endpoints in the gray region.

It will be convenient to distinguish between different parts of the gray region, depending on their position with respect to the red region. We differentiate between five regions, named A,B,C,D,E, as depicted in Fig. 6(c). These five regions are obtained by drawing horizontal and vertical lines through the two corners of the red region.

We say that the type of a segment $s$ is XY, for $\text{X,Y}\in\{A,B,C,D,E\}$ if $s$ has one endpoint in region X and the other endpoint in region Y. The next lemma shows that, after (a successful) cascading, there are only a few possible types.

Lemma 4

Any unclassified segment after the cascading procedure is of type in $AC$, $AD$, $AE$, $BE$, or $CE$.

Proof

The claim follows from the fact that there cannot be a segment completely to the right, left or above the red region. More formally, assume that there exists a segment $s\in S$ of type $XY$, for $X,Y\in\{A,B\}$. By Lemma 3, we know that $p_{\ell}$ is classified as red, and in particular both endpoints of $s$ are to the left of $p_{\ell}$. However, this contradicts with the definition of $s_{\ell}$. Similarly, segments of type $XY$, for $X,Y\in\{B,C,D\}$ would give a contradiction with $s_{t}$, and with $s_{r}$ for $X,Y\in\{D,E\}$.

Now, consider the red and blue regions obtained after cascading. Let $p_{1},\dots,p_{k}$ be the endpoints of segments of $S$ inside region A, as they appear from left to right. In addition, we define $p_{0}$ as the blue point defining the blue boundary of region A, and $p_{k+1}$ as the red point defining the red boundary of region $A$. See Fig. 7(a). Let $G_{i}$, for $1\leq i\leq k+1$, be the gray region obtained after classifying points $p_{1},\dots,p_{i-1}$ as blue, $p_{i},\dots,p_{k}$ as red, and performing a cascading procedure (see Fig. 7(b-d)). If any of those cascading operations results in a contradiction being found, we simply set the corresponding $G_{i}$ to be empty.

Observe that, if for some $i$, $G_{i}\neq\emptyset$, then any unclassified segment (i.e., segment with both endpoints in $G_{i}$) must be of type BE or CE.

Next we upper-bound the number of ways in which $G_{i}$ can be completed to a solution.

Lemma 5

Let $G_{i}$ be defined as above for some $1\leq i\leq k+1$ such that $G_{i}\neq\emptyset$, and let $n_{i}$ be the number of unclassified segments in $G_{i}$. Then there are at most $n_{i}$ combinatorially different solutions that use the classification induced by $G_{i}$.

Proof

Since all unclassified segments are of type BE or CE, each of them has one endpoint in region E. In any solution based on the classification induced by $G_{i}$, the right boundary of the red region must cross somewhere within E. Without loss of generality, assume it goes through a point in E (since there cannot be endpoints of unclassified segments in region D).

This implies that if we fix the right side of such a solution, the classification of all unclassified segments becomes fixed. To see this, let $p$ be the endpoint in E through which the right side of the solution goes. Fixing $p$ implies classifying all other segments that have an endpoint in E (those to the left of $p$ must be red, the others blue). Since all remaining unclassified segments have an endpoint in E, they all become classified. It follows that there is at most one combinatorially different solution for each point in E, of which there are $n_{i}$.

We are now ready to show that the total number of combinatorially different solutions is linear.

Lemma 6

For any set $S$ of $n$ segments there are $O(n)$ combinatorially different stabbing 3-rectangles.

Proof

It suffices to show that an unclassified segment in region $G_{i}$ cannot be unclassified in $G_{j}$ for $i\neq j$. This fact, combined with Lemma 5, implies that the total number of possible solutions is $O(n)$. We can see $G_{i}$ as defined by three intervals, one on the left (i.e., region A), one on top (region C) and one on the right (region E). Actually, regions B and D can be more complex in $G_{i}$ (the upper left and right boundaries may form a increasing and decreasing staircase shape, respectively), but we ignore this fact for the proof.

The left interval is initially defined by the gap in $x$-coordinates between $p_{i-1}$ and $p_{i}$, although the posterior cascading procedure can limit it further. In particular, an unclassified segment in $G_{i}$ must have an endpoint whose $x$-coordinate lies between those of $p_{i}$ and $p_{i+1}$.

Assume for the sake of contradiction, that there exist two indices $i,j$ such that $1\leq i<j\leq k+1$ and a segment $s\in S$ such that $s$ is unclassified in both $G_{i}$ and $G_{j}$. We distinguish two cases depending on whether $s$ is of type BE or CE.

First consider the (simpler) case in which $s$ is of type BE. From the above reasoning we conclude that $s$ has an endpoint whose $x$-coordinate lies between those of $p_{i}$ and $p_{i+1}$, and another endpoint between $p_{j}$ and $p_{j+1}$. These intervals are disjoint whenever $i\neq j$. In particular, this implies that both endpoints of $s$ are to the left of the red region, which would contradict Lemma 4.

It remains to consider the case in which $s$ is of type CE. We claim that either the top interval or the right interval of $G_{i}$ is disjoint from the corresponding interval of $G_{j}$. Let $\{p_{i},q_{i}\}$ be the segment with endpoint at $p_{i}$. Recall that this segment can be of type AC, AD or AE. Since we assumed that $i<j$, we know that $p_{i}$ is red, and $q_{i}$ is blue in $G_{i}$, whereas the opposite assignment occurs in $G_{j}$. This implies that the region where $q_{i}$ is (C, D or E), changes its gray interval to a new interval that must be disjoint from the previous one. Namely, if $q_{i}$ lies on C or D, then the red region changes from ending strictly below $q_{i}$ to at least containing $q_{i}$. On the other hand, if $q_{i}$ lies on E, the red region changes from ending strictly to the left of $q_{i}$ to containing it. Thus, either the top or right intervals of $G_{i}$ and $G_{j}$ are disjoint, implying no segment of type CE can be in both.

3.2 Algorithm

The previous results give rise to a natural algorithm to generate all combinatorially different stabbing 3-rectangles. The algorithm has two phases:

Initial cascading

We initialize the red region using Lemma 3 and launch the usual cascading procedure. If this cascading finishes without finding a contradiction, we obtain a red and a blue region that must be included and avoided by any 3-rectangle stabber, respectively.

Plane sweep of region A

Now we sweep the points in region A from left to right. In the $i$th step of the sweep, we classify points $p_{1},\dots,p_{i-1}$ as blue, and points $p_{i},\dots,p_{k}$ as red. After each such step, we perform a cascading procedure. If the cascading gives no contradiction, we are left with a gray region $G_{i}$ and a number of unclassified segments that must be of type BE or CE. Then we sweep the endpoints of the unclassified segments in region E from left to right (we call this the secondary sweep). At each step of the sweep, we fix those to the left of the sweep line as red, and those to the right of the sweep line as blue, and perform a third cascading procedure. From the proof of Lemma 5, we know that each step of this second sweep, after the corresponding cascading procedure, can produce at most one different solution.

Theorem 3.1

All combinatorially different stabbing 3-rectangles for a set $S$ of $n$ segments can be computed in $O(n\log n)$ time.

Proof

First we note that there is an $O(n\log n)$ time preprocessing cost for obtaining the different orders of the endpoints of the segments by increasing and decreasing of their $x$ and $y$ coordinates.

Next we analyze the time needed in the initial cascading process. Each time an endpoint is colored, we can check in at most $O(\log n)$ time if it creates a contradiction: this is done similarly to the previous section, where we maintain the intervals in regions A, C and E, and the staircases in regions B and D in dynamic data structures that allow for logarithmic-time updates. Thus, the total time needed to check whether there is an initial solution is $O(n\log n)$. Using the same structure, we can detect contradictions and update regions when a point is recolored (in either the sweep of region A or a secondary sweep).

In addition, after each step of the sweep in region A we must revert certain colorings. Recall that in the $i$th step we classify points $p_{1},\dots,p_{i-1}$ as blue and points $p_{i},\dots,p_{k}$ as red. After the i$th$ step, we need to undo the colorings that are a consequence of setting $p_{i}$ red, since from the next step on, $p_{i}$ will be blue. This can be done efficiently by precomputing, for each point $p$, the largest $j$ such that a $p_{j}$ in region A will force a coloring of $p$. In this way, the total time spent reverting colorings, after preprocessing, is $O(n)$. The extra preprocessing time needed to precompute this information is $O(n\log n)$.

Overall, the sweep process of region A (disregarding the secondary sweeps) needs $O(n\log n)$ time, since at most $O(\log n)$ time is spent per each segment. The secondary sweep of $n_{i}$ points in region E, including all the cascading procedure, can be done in $O(n_{i}\log n_{i})$ time. Since the groups of points swept in region E in each step are disjoint, the total cost of all cascadings in secondary sweeps is also bounded by $O(n\log n)$.

4 Stabbing rectangles

In this section we consider the computation of rectangular stabbing regions. Even though we would like to use a cascading-based approach, like the ones used in previous sections, it is not clear how this can be done. Indeed, a fundamental property for the cascading procedure to work is that we can find some region of the plane that must be contained in all non-trivial stabbers (see Observation 3, Observation 4, and Lemma 3). Unfortunately, it seems difficult to use a similar approach for rectangles because it is not clear how to apply a cascading procedure efficiently. Indeed, an important difference with the previous cases is that the $x$ and $y$ coordinates can behave independently, and thus it is hard to track the relationship between the two dimensions with a cascading procedure (see Figure 8).

Instead, we use a different approach to compute all stabbing rectangles. Any inclusionwise smallest stabbing rectangle $R$ must contain one endpoint on each side, and in particular, an endpoint $v$ of $S$ must be on its lower boundary segment (otherwise, we could shrink it further).

The key observation is that if we fix $v$ (or equivalently, the lower side of a candidate stabbing rectangle), then we can reduce the problem to that of finding a $3$-sided rectangle. In particular, by fixing the lower side of the rectangle we are forcing all points below it to be blue (and as a result the corresponding endpoint of the segment must be red). After a successful cascading procedure, we end up with a certain initial classification that can be completed to a solution to the rectangle if and only if a compatible stabbing $3$-sided rectangle exists. Since there are $2n$ candidates for $v$ (each of the endpoints of the segments of $S$), we have $O(n)$ different instances that can be solved independently using Theorem 3.1. Therefore we obtain the following result.

Theorem 4.1

All the combinatorially different stabbing rectangles for a set $S$ of $n$ segments can be computed in $O(n^{2}\log n)$ time.

Proof

The bottleneck of the algorithm is the $O(n)$ times that we invoke the algorithm of Theorem 3.1. Between two such calls, we execute a cascading procedure. As in previous cases, a segment can only be classified once in this manner, thus this cascading will need overall $O(n\log n)$ time.

Each time we find a stabbing rectangle, we must make sure it is non-trivial (i.e., determine if it can be extended to a stabbing 3-rectangle). This is done in $O(\log n)$ time with a constant number of orthogonal range search queries (as described in the proofs of Theorems 2.4 and 3.1). Also note that the linear bound on the number of possible 3-rectangles (Lemma 6) immediately implies a quadratic bound on the number of possible stabbing rectangles. In fact, it is not hard to build a set of segments with $\Theta(n^{2})$ combinatorially different stabbing rectangles (such an example is shown in Figure 8).

5 Conclusions and open problems

In this paper we introduced a general algorithm for computing all combinatorially different stabbers of a set of segments, which classifies the endpoints based on partitioning the plane into red, blue, and gray regions that are updated as points become classified. We showed how to apply such strategy to horizontal strips, quadrants, $3$-sided rectangles and, indirectly, to axis-aligned rectangular stabbers. Furthermore, we have proved that our algorithms for horizontal strips, quadrants, and $3$-sided rectangles are asymptotically optimal (under a mild assumption on the description of the stabbing region), while the algorithm for rectangles has only a logarithmic factor overhead.

This work gives rise to several directions for future work. One of them is studying the decision version of the problems. That is, what if one only needs to know if one stabber of a certain shape exists? It is an intriguing open problem whether one can solve the decision versions of the problems faster, even for the case of horizontal strips. This was shown not to be possible for line stabbers [8, 21], but it is unclear if this is also the case in our context. In our setting, an important difficulty for devising a more efficient algorithm for the decision version is that there does not seem to exist any local condition that determines whether a solution exists. As shown in Figure 9, it may be necessary to analyze a linear number of segments (with the corresponding cascading iterations) to find out that a subset of them forces a stabbing region that is not compatible with some other segment. It is unclear whether some different approach could yield a $o(n\log n)$ algorithm for this problem.

Other natural algorithmic extensions include designing an output-sensitive algorithm to report all combinatorially different stabbing rectangles, with running time proportional to the number of solutions, and studying the optimization variants of the problems for the cases in which no stabber exists. For those cases, it would be useful to have an efficient algorithm to find a stabber that classifies as many segments as possible.

Finally, another relevant family of problems arises from looking for stabbers with arbitrary orientations (instead of rectilinear). For the case of lines, going from fixed-orientation lines to any line increases the running time from $O(n)$ to $\Omega(n\log n)$ time [21]. In our setting, there are only $O(n^{2})$ relevant directions, hence our algorithms could be used for this variants if applied to each of the relevant directions, yielding an $O(n^{2})$ multiplicative increase in the running time. Designing more efficient algorithms for this case is clearly an interesting open problem.

Acknowledgments.

M. C., C. S., and R.I. S were partially supported by projects MINECO MTM2015-63791-R/FEDER and Gen. Cat. DGR2014SGR46. D. G. was supported by projects PAI FQM-0164 and MTM2014-60127-P. M. K. was supported in part by the ELC project (MEXT KAKENHI No. 12H00855 and 15H02665). R.I. S. was also partially supported by MINECO through the Ramón y Cajal program.