9,770 research outputs found
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
Reporting Bichromatic Segment Intersections from Point Sets
In this paper, we introduce a natural variation of the problem of computing all bichromatic intersections between two sets of segments. Given two sets R and B of n points in the plane defining two sets of segments, say red and blue, we present an O(n2) time and space algorithm for solving the problem of reporting the set of segments of each color intersected by segments of the other color. We also prove that this problem is 3-Sum hard and provide some illustrative examples of several point configurations
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 and with query time
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 and query time . When the objects and
query are fat, we obtain query time using storage
On Ray Shooting for Triangles in 3-Space and Related Problems
We consider several problems that involve lines in three dimensions, and
present improved algorithms for solving them. The problems include (i) ray
shooting amid triangles in , (ii) reporting intersections between query
lines (segments, or rays) and input triangles, as well as approximately
counting the number of such intersections, (iii) computing the intersection of
two nonconvex polyhedra, (iv) detecting, counting, or reporting intersections
in a set of lines in , and (v) output-sensitive construction of an
arrangement of triangles in three dimensions.
Our approach is based on the polynomial partitioning technique.
For example, our ray-shooting algorithm processes a set of triangles in
into a data structure for answering ray shooting queries amid the given
triangles, which uses storage and preprocessing, and
answers a query in time, for any . This
is a significant improvement over known results, obtained more than 25 years
ago, in which, with this amount of storage, the query time bound is roughly
. The algorithms for the other problems have similar performance
bounds, with similar improvements over previous results.
We also derive a nontrivial improved tradeoff between storage and query time.
Using it, we obtain algorithms that answer queries on objects in time, for any
, again an improvement over the earlier bounds.Comment: 33 pages, 7 figure
Drawing Arrangement Graphs In Small Grids, Or How To Play Planarity
We describe a linear-time algorithm that finds a planar drawing of every
graph of a simple line or pseudoline arrangement within a grid of area
O(n^{7/6}). No known input causes our algorithm to use area
\Omega(n^{1+\epsilon}) for any \epsilon>0; finding such an input would
represent significant progress on the famous k-set problem from discrete
geometry. Drawing line arrangement graphs is the main task in the Planarity
puzzle.Comment: 12 pages, 8 figures. To appear at 21st Int. Symp. Graph Drawing,
Bordeaux, 201
- …