Finding Pairwise Intersections of Rectangles in a Query Rectangle

We consider the following problem: Preprocess a set S of n axis-parallel boxes in mathbb{R}^d so that given a query of an axis-parallel box Q in mathbb{R}^d, the pairs of boxes of S whose intersection intersects the query box can be reported efficiently. For the case that d=2, we present a data structure of size O(nlog n) supporting O(log n+k) query time, where k is the size of the output. This improves the previously best known result by de Berg et al. which requires O(log nlog^* n+ klog n) query time using O(nlog n) space.There has been no known result for this problem for higher dimensions, except that for d=3, the best known data structure supports O(sqrt{n}+klog^2log^* n) query time using O(nsqrt {n}log n) space. For a constant d>2, we present a data structure supporting O(n^{1-delta}log^{d-1} n + k polylog n) query time for any constant 1/dleqdelta<1.The size of the data structure is O(n^{delta d}log n) if 1/dleqdelta<1/2, or O(n^{delta d-2delta+1}) if 1/2leq delta<1

Finding Pairwise Intersections Inside a Query Range

We study the following problem: preprocess a set O of objects into a data structure that allows us to efficiently report all pairs of objects from O that intersect inside an axis-aligned query range Q. We present data structures of size $O(n({\rm polylog} n))$ and with query time $O((k+1)({\rm polylog} n))$ time, where k is the number of reported pairs, for two classes of objects in the plane: axis-aligned rectangles and objects with small union complexity. For the 3-dimensional case where the objects and the query range are axis-aligned boxes in R^3, we present a data structures of size $O(n\sqrt{n}({\rm polylog} n))$ and query time $O((\sqrt{n}+k)({\rm polylog} n))$. When the objects and query are fat, we obtain $O((k+1)({\rm polylog} n))$ query time using $O(n({\rm polylog} n))$ storage

Searching edges in the overlap of two plane graphs

Consider a pair of plane straight-line graphs, whose edges are colored red and blue, respectively, and let n be the total complexity of both graphs. We present a O(n log n)-time O(n)-space technique to preprocess such pair of graphs, that enables efficient searches among the red-blue intersections along edges of one of the graphs. Our technique has a number of applications to geometric problems. This includes: (1) a solution to the batched red-blue search problem [Dehne et al. 2006] in O(n log n) queries to the oracle; (2) an algorithm to compute the maximum vertical distance between a pair of 3D polyhedral terrains one of which is convex in O(n log n) time, where n is the total complexity of both terrains; (3) an algorithm to construct the Hausdorff Voronoi diagram of a family of point clusters in the plane in O((n+m) log^3 n) time and O(n+m) space, where n is the total number of points in all clusters and m is the number of crossings between all clusters; (4) an algorithm to construct the farthest-color Voronoi diagram of the corners of n axis-aligned rectangles in O(n log^2 n) time; (5) an algorithm to solve the stabbing circle problem for n parallel line segments in the plane in optimal O(n log n) time. All these results are new or improve on the best known algorithms.Comment: 22 pages, 6 figure

Covering Points by Disjoint Boxes with Outliers

For a set of n points in the plane, we consider the axis--aligned (p,k)-Box Covering problem: Find p axis-aligned, pairwise-disjoint boxes that together contain n-k points. In this paper, we consider the boxes to be either squares or rectangles, and we want to minimize the area of the largest box. For general p we show that the problem is NP-hard for both squares and rectangles. For a small, fixed number p, we give algorithms that find the solution in the following running times: For squares we have O(n+k log k) time for p=1, and O(n log n+k^p log^p k time for p = 2,3. For rectangles we get O(n + k^3) for p = 1 and O(n log n+k^{2+p} log^{p-1} k) time for p = 2,3. In all cases, our algorithms use O(n) space.Comment: updated version: - changed problem from 'cover exactly n-k points' to 'cover at least n-k points' to avoid having non-feasible solutions. Results are unchanged. - added Proof to Lemma 11, clarified some sections - corrected typos and small errors - updated affiliations of two author