16 research outputs found
Spanning trees crossing few barriers
We consider the problem of finding low-cost spanning trees for sets of n points in the plane,
where the cost of a spanning tree is defined as the total number of intersections of tree edges
with a given set of m barriers. We obtain the following results:
(i) if the barriers are possibly intersecting line segments, then there is always a spanning
tree of cost O(min(m2,m SQRT(n)));
(ii) if the barriers are disjoint line segments, then there is always a spanning tree of cost
O(m);
(iii) if the barriers are disjoint convex objects, then there is always a spanning tree of cost
O(n + m).
All our bounds are worst-case optimal
Computing the visibility map of fat objects
AbstractWe give an output-sensitive algorithm for computing the visibility map of a set of n constant-complexity convex fat polyhedra or curved objects in 3-space. Our algorithm runs in O((n+k) polylog n) time, where k is the combinatorial complexity of the visibility map. This is the first algorithm for computing the visibility map of fat objects that does not require a depth order on the objects and is faster than the best known algorithm for general objects. It is also the first output-sensitive algorithm for curved objects that does not require a depth order
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
Dense point sets have sparse Delaunay triangulations
The spread of a finite set of points is the ratio between the longest and
shortest pairwise distances. We prove that the Delaunay triangulation of any
set of n points in R^3 with spread D has complexity O(D^3). This bound is tight
in the worst case for all D = O(sqrt{n}). In particular, the Delaunay
triangulation of any dense point set has linear complexity. We also generalize
this upper bound to regular triangulations of k-ply systems of balls, unions of
several dense point sets, and uniform samples of smooth surfaces. On the other
hand, for any n and D=O(n), we construct a regular triangulation of complexity
Omega(nD) whose n vertices have spread D.Comment: 31 pages, 11 figures. Full version of SODA 2002 paper. Also available
at http://www.cs.uiuc.edu/~jeffe/pubs/screw.htm
Vertical ray shooting and computing depth orders of fat objects
We present new results for three problems dealing with a set of convex constant-complexity fat polyhedra in 3-space. (i) We describe a data structure for vertical ray shooting in that has query time and uses storage. (ii) We give an algorithm to compute in time a depth order on if it exists. (iii) We give an algorithm to verify in time whether a given order on is a valid depth order. All three results improve on previous results
Trajectory Visibility
We study the problem of testing whether there exists a time at which two entities moving along different piece-wise linear trajectories among polygonal obstacles are mutually visible. We study several variants, depending on whether or not the obstacles form a simple polygon, trajectories may intersect the polygon edges, and both or only one of the entities are moving. For constant complexity trajectories contained in a simple polygon with n vertices, we provide an (n) time algorithm to test if there is a time at which the entities can see each other. If the polygon contains holes, we present an (n log n) algorithm. We show that this is tight. We then consider storing the obstacles in a data structure, such that queries consisting of two line segments can be efficiently answered. We show that for all variants it is possible to answer queries in sublinear time using polynomial space and preprocessing time. As a critical intermediate step, we provide an efficient solution to a problem of independent interest: preprocess a convex polygon such that we can efficiently test intersection with a quadratic curve segment. If the obstacles form a simple polygon, this allows us to answer visibility queries in (n³/4log³ n) time using (nlog⁵ n) space. For more general obstacles the query time is (log^k n), for a constant but large value k, using (n^{3k}) space. We provide more efficient solutions when one of the entities remains stationary