SIAM J. COMPUT.


c 2006 Society for Industrial and Applied Mathematics
Vol. 35, No. 3, pp. 627–646

SUBLINEAR GEOMETRIC ALGORITHMS∗

BERNARD CHAZELLE† , DING LIU† , AND AVNER MAGEN‡

Abstract. We initiate an investigation of sublinear algorithms for geometric problems in two

and three dimensions. We give optimal algorithms for intersection detection of convex polygons and
polyhedra, point location in two-dimensional triangulations
√and Voronoi diagrams, and ray shooting
in convex polyhedra, all of which run in expected time O( n ), where n is the size of the input. We
also provide sublinear solutions for the approximate evaluation of the volume of a convex polytope
and the length of the shortest path between two points on the boundary.

Key words. sublinear algorithms, approximate shortest paths, polyhedral intersection

AMS subject classifications. 68Q25, 68W05, 68W20, 68W40

DOI. 10.1137/S009753970444572X

1. Introduction. As an outgrowth of the recent work on property testing, the

study of sublinear algorithms has emerged as a field unto itself, and great strides have
been made in the context of graph and combinatorial problems [30]. Large geometric
datasets often call for algorithms that examine only a small fraction of the input,
but it is fair to say that sublinear computational geometry is still largely uncharted
territory. If preprocessing is allowed, then, of course, this is an entirely different
story [3, 23]. For example, checking whether a point lies in a convex 3-polyhedron
can be done in logarithmic time with linear preprocessing. However, little of this
technology is of any use with massive datasets, since examining the whole input—
let alone preprocessing it—is out of the question. Sublinear algorithms have been
given for dynamic problems [17] or in situations where a full multidimensional data
structure is available [10]. There has also been work on geometric property testing,
both in an approximate [11, 12, 18] and exact [24] setting.
In this paper, sublinearity is understood differently. The input is taken to be in
any standard representation with no extra assumptions. For example, a planar subdi-
vision or a polyhedron is given in classical edge-based fashion (e.g., doubly connected
edge list (DCEL), winged-edge), with no extra preprocessing. This implies that we can
pick an edge at random in constant time, but we cannot sample randomly among the
neighbors of a given vertex in constant time. Our motivation is twofold: (i) we seek
the minimal set of computational assumptions under which sublinearity is achievable;
(ii) the assumptions should be realistic and nonrestrictive. Note, for example, that
sublinear separation algorithms for convex objects are known [6, 15], but all of them
require preprocessing, so they fall outside our model. Under these conditions one
might ask whether there exist any interesting “offline” problems that can be solved
in sublinear time. The answer is yes. Note that randomization is a necessity be-

∗ Received by the editors August 16, 2004; accepted for publication (in revised form) June 20, 2005;

published electronically January 6, 2006. A preliminary version of this paper appeared in Proceedings
of the 35th Annual ACM Symposium on Theory of Computing, San Diego, 2003, pp. 531–540. This
work was supported in part by NSF grants CCR-998817 and ARO grant DAAH04-96-1-0181 and by
the NEC Research Institute.
http://www.siam.org/journals/sicomp/35-3/44572.html
† Department of Computer Science, Princeton Univeristy, Princeton, NJ, 08544 (chazelle@cs.

princeton.edu, [email protected]).
‡ Department of Computer Science, University of Toronto, Toronto, ON, M5S3G4 Canada (avner@

cs.toronto.edu).
627
628 BERNARD CHAZELLE, DING LIU, AND AVNER MAGEN

cause, in a deterministic setting, most problems in computational geometry require

looking at the entire input. There has been some (but little) previous work on sub-
linear geometric algorithms as we define them, specifically point location in two- and
three-dimensional Delaunay triangulations of sets of random points [14, 27]. As far
as we know, however, these are the only works that fall inside our model. Here is a
summary of our results. In all cases, n denotes the input size, and all polyhedra are
3
understood to be in R√ :
• an optimal O( n ) time algorithm for checking whether two convex polyhedra
intersect, reporting an intersection point if they do and a separating plane if
they do not;√
• optimal O( n ) time algorithms for point location in planar convex subdivi-
sions with O(1) maximum face size and two-dimensional Voronoi diagrams,
finding the nearest neighbor on a convex polyhedron, and ray shooting-type
problems in convex polyhedra.
In contrast with property testing, it is important to note that our algorithms never
err. All the algorithms are of Las Vegas type, and randomization affects the running
time but not the correctness of the output.1 Devroye, Mücke, and Zhu [14] showed
that a simple technique for point location in two-dimensional Delaunay triangulations,
namely random sampling then walking from the nearest sample to the query, has
expected running time (roughly) O(n1/3 ) for n random input points and a random
query. This does not contradict the optimality of our O(n1/2 ) bound because the
points must be chosen randomly in [14].
We also consider optimization problems for which approximate solutions are
sought. We give √
• an O(ε−1 n ) time algorithm for approximating the volume of a convex poly-
tope with arbitrary
√ relative error ε > 0;
• an O(ε−5/4 n ) + f (ε−5/4 ) time algorithm for approximating the length of
the shortest path between two points on the boundary of a convex polyhedron
with arbitrary relative error ε > 0. Here, f (n) denotes the complexity of the
exact√version of problem. This implies that the complexity of our algorithm
is O( n ) for any fixed ε > 0.
The shortest path problem for polyhedral surfaces has been extensively stud-
ied, drawing its motivation from applications in route planning, injection molding,
and computer assisted surgery [1, 21, 26]. In the convex case (the one at hand),
an O(n3 log n) algorithm was given by Sharir and Schorr [32], later improved by
Mitchell, Mount, and Papadimitriou [25] to O(n2 log n) and by Chen and Han [7] to
O(n2 ); therefore, it is known that f (n) = O(n2 ). More recently, Kapoor [22] has
announced a proof
√ that f (n) = O(n log2 n), which would make our algorithm run in
−5/4
time O(ε n ). This improves on Agarwal et al.’s algorithm [2], which runs in
O(n log ε−1 + ε−3 ) time for any ε > 0.
Our method makes progress on an important geometric problem of independent
interest.
• Given a convex polytope P of n vertices, how many vertices must an enclosing
polytope Q have if it is to approximate any (large enough) shortest path on
∂P with relative error at most ε? We reduce to O(ε−5/4 ) the best previous
bound of O(ε−3/2 ), due to Agarwal et al. [2].

1 Throughout this paper, unless specified otherwise, the running times are understood in the

expected sense.
 SUBLINEAR GEOMETRIC ALGORITHMS 629

A Flavor of the Techniques. As a warmup exercise, consider the classical successor

searching problem: Given a sorted (doubly linked) list of n keys and a number x, find
the smallest key y ≥ x (the successor of x) in the list or√report that none exists. It
is well known that √ this smallest key can be found in O( n) expected time [19]. For
this, we choose n list elements at random and find the predecessor and successor
of x among those. (Perhaps only one exists.) This provides an entry point into the
list, from which a naive search takes us to the successor. To make random sampling
possible, we may assume that the list elements are stored in consecutive locations
(say, in a table). However—and this is the key point—no assumption is made on the
ordering of the elements in the table. (Otherwise we could do a binary search.)
√
Lemma 1.1. Successor searching can be done in O( n ) expected time per query,
which is optimal.
Proof. For i ≥ 1, let Qi be the set of all elements that are at distance at
most i away from the answer on the √ list (in either direction). Let P>i be the
probability of not hitting Qi after n random choices of the list elements. The
expected
 distance of the answer to its nearest neighbor in the √ random
 sample is
i(P >i−1 − P >i ) = P
i≥0 >i . This sum is upper bounded by n P
c≥0 >c n
√ ≤
√ i≥1 √ √ √  √
n c≥0 (1 − c/ n) n = n c≥0 2−Ω(c) = O( n). This immediately implies that
√
the expected time of the algorithm is O( n ).
For the lower bound, we use Yao’s minimax principle [33]. We fix a distribution
on the input, and we lower-bound the expected complexity of any deterministic algo-
rithm. We then have the same lower bound for randomized algorithms. The input is a
linked list containing the numbers 1 through n in sorted order. In our model, the list
is represented by a table T [1 · · · n], with the ith element in the list stored in location
σ(i) of the table; hence, T [σ(i)] = i. The input distribution is formed by choosing the
permutation σ uniformly from the symmetric group on n elements. In other words,
all permutations are equally likely. The query is set to be n. In other words, the
problem is to locate the last element in the list. A deterministic algorithm can be
modeled as a sequence of steps of the following form: (A) pick a location T [k] already
visited and look up the next (or previous) item, i.e., T [σ(i ± 1)], where k = σ(i); (B)
compute a new index k and look up T [k]. Each step may involve the consideration of
every piece of information gathered so far. In particular, in a B-step we may not con-
sult either one of the adjacent items in the list before computing k (unless, of course,
these items were visited earlier). In this way, σ −1 (k) of a B-step is equally likely to
lie anywhere in the portion of the list still unvisited. For this reason, after a A-steps
 √
n+a+b b √
and b B-steps, there is a probability at least 1 − n that none of the last n
elements in the list has been visited in a B-step.
√ Right after the last B-step, either the
total √number of A- and B-steps exceeds n or, with constant nonzero probability, at
least n A-steps (some of which may have already been taken) are required to reach
the last element in the list. This
√ immediately implies that the expected time of any
deterministic algorithm is Ω( n ).
We can generalize these ideas to polygon intersection. Given two convex polygons
P and Q, with n vertices each, determine whether they intersect or not and, if they
do, report one point in the intersection. We assume that P and Q are given by their
doubly linked lists of vertices (or edges) such that each vertex points to its predecessor
and successor in clockwise order. As in successor searching, we assume that the two
lists are stored in two tables to allow random sampling.
Choose a random sample of r vertices from each polygon, and let Rp ⊆ P and
Rq ⊆ Q denote the two corresponding convex hulls. By two-dimensional linear pro-
630 BERNARD CHAZELLE, DING LIU, AND AVNER MAGEN

Rq

Rp
p
1 Cp
p
p
2

Fig. 1. Intersecting two convex polygons.

gramming, we can test Rp and Rq for intersection without computing them explicitly.
This can be done probabilistically (or even deterministically) in linear time. There
are many ways of doing that (see [5] for references). It is easy to modify the algorithm
(of, say, [31]) so that in O(r) time it reports a point in the intersection of Rp and Rq
if there is one (in which case we are done) and a bitangent separating line L otherwise
(Figure 1). Let p be the vertex of Rp in L, and let p1 , p2 be its two adjacent vertices
in P . We define a polygon Cp as follows. If neither p1 nor p2 is on the Rq side of L,
then Cp is the empty polygon. Otherwise, by convexity exactly one of them is (say,
p1 ). We walk along the boundary of P starting at p1 , away from p, until we cross L
again. This portion of the boundary, clipped by the line L, forms the convex polygon
Cp . A similar construction for Q leads to Cq .
It is immediate that P ∩ Q = ∅ if and only if P intersects Cq or Q intersects
Cp . We check the first condition and, if it fails, check the second one. We restrict
our explanation to the case of P ∩ Cq . First, we check whether Rp and Cq intersect,
again using a linear time algorithm for a linear program (LP), and return with an
intersection point if they do. Otherwise, we find a line L that separates Rp and
Cq and, using the same procedure as described above, we compute the part of P ,
denoted Cp , on the Cq side of L . Finally, we test Cp and Cq for intersection in time
linear on their sizes, using an LP or any other straightforward linear-time algorithm
for intersection detection of convex polygons. Correctness is immediate. The running
time is O(r + |Cp | + |Cp | + |Cq | + |Cq |). We can prove that E |Cp | = O(n/r). (The
three-dimensional case discussed below will subsume this result, so there is no need for
a proof now.) Similarly, E |Cp | = E |Cq | = E |Cq | = √
O(n/r). The overall complexity
of √the algorithm is O(r + n/r), and choosing r = n
gives the desired bound of
O( n ).
To show optimality, consider the following distributions on pairs of polygons. One
polygon is fixed, convex, and nondegenerate with one vertex in the origin and all other
vertices below the x-axis. The other polygon (also convex and nondegenerate) has
n−1 vertices above the x-axis, and one vertex, p, in the origin or in (0, δ), where δ is a
positive number small enough so that p is the lowest vertex of the polygon. Moreover,
the edges of this polygon are randomly ordered in the edge table. Clearly, these two
polygons intersect if and only if p is in the origin. Since nothing in the structure of the
input except the geometry of p reveals whether it is indeed the origin, any algorithm
that detects intersection must have access to p. Now recall that the only operations
allowed are the random sampling of edges and edge-traversing via links, which means
 SUBLINEAR GEOMETRIC ALGORITHMS 631
√
that, as in Lemma 1.1, an expected time of Ω( n) is needed to access p. Optimality
of subsequent results follows these lines very closely and shall not be proved again.
We have the following.
√Theorem 1.2. To check whether two convex n-gons intersect can be done in
O( n ) time, which is optimal.
To put Theorem 1.2 in perspective, recall that the intersection of two convex
polygons can be determined in logarithmic time if the vertices are stored in an array
in cyclic order [6]. The key point of our result is that, in fact, a linked list is sufficient
for sublinearity. Similarly, if polyhedra are preprocessed à la Dobkin and Kirkpatrick,
then fast intersection detection is possible [15]. What we show below is that sublinear-
ity is achievable even with no preprocessing at all. Again, we use a two-stage process:
In the first stage we break up the problem into r subproblems of size roughly n/r and
then identify which ones actually need to be solved; in the second stage we solve these
subproblems in standard (i.e., nonsublinear) fashion. Their number is constant, and
hence the square root complexity. What prevents us from solving these subproblems
recursively is the model’s restriction to global random sampling. In other words, one
can sample efficiently for the main problem but not for the subproblems.
2. Convex polyhedral intersections. Given two n-vertex convex polyhedra
P and Q in R3 , the problem is to determine whether or not they intersect: If they
do, then we should report a point in the intersection; otherwise, we should report
a plane that separates them. We assume that a convex polyhedron is given in any
classical edge-based fashion (e.g., DCEL, winged-edge) but with no extra preprocess-
ing. The main structure is a table of edges that allows us to pick an edge at random
in constant time. There are also two tables for vertices and faces. Moreover, these
tables are interconnected via pointers to make various local operations possible. For
example, each edge points to its two vertices and two adjacent faces. It also points
to its predecessor and successor edges in its two adjacent faces. Such a structure is
a standard representation for convex polyhedra in computational geometry. It allows
us to traverse a portion of a convex polyhedron in a local fashion and in time linear
in the number of edges visited. √
Choose a random sample of r = n
edges from P and Q, and let Rp and Rq
denote the convex hulls of these random edges in P and Q, respectively. We do not
compute Rp and Rq explicitly but merely use their vertices to get an LP as described
in the last section for the case of polygons. We use this LP to detect the intersection
of Rp and Rq in O(r) time by invoking a linear-time algorithm for low-dimensional
linear programming. We stop with a point of intersection if there is one. Otherwise,
we find a separating plane L that is tangent to both Rp and Rq . It is important to
choose the plane L in a canonical fashion. To do that, we set up the LP so as to
maximize, say, the coefficient α in the equation2 αx + βy + γz = 1 of L.
Next, choose a plane π normal to L and consider projecting P and Q onto it. (Of
course, we do not actually do it.) Let p be a vertex of Rp in L (there could be two
of them, but not more, if we assume general position between P and Q), and let p∗
be its projection onto π. We also project the neighbors of p in P onto π and get
p∗1 ,p∗2 , . . ., p∗k . In other words, they are the set of vertices adjacent to p∗ in the
projection of P onto π. We test to see if any of them is on the Rq side of L and
identify one such point, p1 , if the answer is yes (more on that below). If none of them
2 With perturbation techniques, we can always assume general position, and hence avoid having

a solution passing through the origin. We will also assume that the relative position of P and Q is
general.
632 BERNARD CHAZELLE, DING LIU, AND AVNER MAGEN

p
1
f
p

Fig. 2. The edges of P incident to p; the thick lines form the random sample.

is on the Rq side, then we define Cp to be the empty polyhedron. This is because

in this case, P is completely on the other side of L. Otherwise, we construct the
portion of P , denoted Cp , that lies on the Rq side of L. Note that Cp is a convex
polytope, not just the boundary of P cut off by L. We compute Cp by using a standard
flooding mechanism. Beginning at p1 , we perform a depth-first search through the
facial structure of P , restricted to the relevant side of L. Because Cp is convex,
the edges form a single connected component, so we never need to leave Cp . This
allows us to build the entire facial representation of Cp in time proportional to its
number of edges. From then on, the algorithm has the same structure as its polygonal
counterpart; i.e., we compute Cp , Cp , Cq , Cq and perform the same sequence of tests.
The question is now, How do we find p1 (if it exists)? To simplify the analysis,
once we have p, we resample by picking r edges in P at random; let E be the subset
of those incident to p. To find p1 , we project on π all of the edges of E. If there
exists an edge of E that is on the Rq side of L, then we identify its endpoint as p1 .
Otherwise, all the edges of E lie on one side of L. We then identify the two extreme
ones (e and f in Figure 2); being extreme means that all the other projected edges
of E lie in the wedge between e and f in π. Assume that e and f are well defined
and distinct. Consider the cyclic list V of edges of P incident to p. The edges of E
break up V into blocks of consecutive edges. It is not hard to prove that pp1 lies in
a block starting or ending with e or f if such a p1 (as defined above) exists. So, we
examine each of these relevant blocks (at most four) exhaustively. If e and f are not
both distinct and well defined, we may simply search for p1 by checking every edge of
P incident to p.
Theorem
√ 2.1. Two convex n-vertex polyhedra in R3 can be tested for intersection
in O( n ) time; this is optimal.
Proof. Optimality was already discussed in the polygonal case, and correctness
follows from elementary convex geometry, so we limit our discussion to the complexity
of the algorithm. Because of the resampling, the expected sizes of the blocks next to
e and f (or, alternatively, the expected size of the neighborhood of p if the blocks are
not distinct) are O(n/r), so the running time is O(r + n/r + E (|Cp | + |Cq |)), where
|Cp | (resp., |Cq |) denotes the number of edges of Cp (resp., Cq ). We may exclude the
other two terms |Cp | and |Cq |, since our upper bound on E (|Cp | + |Cq |) will apply to
them as well. Here is how to bound E (|Cp | + |Cq |) by O(n/r).
We modify the sampling distribution a little. Then we argue that reverting back
to the original setting does not change the asymptotic value of the upper bound. The
modification is twofold: (i) we view P ∪Q as a multiset M where each vertex appears as
 SUBLINEAR GEOMETRIC ALGORITHMS 633

many times as its number of incident edges; (ii) Rp and Rq are formed by picking each
point of M independently with probability r/n and assigning points of P to Rp and
points of Q to Rq . With respect to the modified distribution, |Cp |+|Cq | is proportional
to the number of constraints in M that violate the LP P(Rp , Rq ) used to define L
(with each point of Rp and Rq defining a linear constraint). For technical reasons, we
need to perturb M slightly to make it in general position. Specifically, we move each
point of M away from its corresponding vertex in P or Q by an infinitesimal random
amount, along the corresponding edge of P or Q. After this random perturbation,
the size of the violation set of P(Rp , Rq ) can only increase. To see this, note that
constraints in M that violate P(Rp , Rq ) before the perturbation continue to do so
because the perturbation is infinitesimal; and constraints in M that lie on L before
the perturbation may violate the LP after the perturbation.
To bound the expected size of the violation set, we apply a result proved by
Gärtner and Welzl [19] (and also by Clarkson [9]). Following the notation of the
“Sampling Lemma” in [19], we let the ground set S be the (perturbed) set M . After
sampling a set of points R from M randomly, we set up an LP αx + βy + γz = 1 that
separates Rp and Rq . Note that in this LP, α, β, and γ are variables and (x, y, z) is
a point in R. This LP is set up so as to maximize the variable α, whose optimum
value is a function of R. We set the function φ in [19] to be α. Under this setting, the
extreme elements of Rp and Rq are their vertices on the optimum separating plane
(as implied by the above LP). Since M is in general position, any Rp and Rq have
three extreme elements. The Sampling Lemma in [19] then implies that the expected
size of the violation set is at most 3(n − r)/(r + 1) = O(n/r).
Let D be the original distribution (the one used by the actual algorithm) with r
replaced by 13r. Of course, this scaling has no asymptotic effect on the upper bound
for E (|Cp | + |Cq |). We define an intermediate distribution D1 by going through each
edge (u, v) of P ∪Q twice, selecting it with probability r/n, and then throwing into the
sample both u and v, provided that the edge (u, v) has not yet been selected. (Note
that this implies that u and v are kept out with probability (1 − r/n)2 .) There are at
most 6n edges in P and Q, so the probability that a sample from D1 is of size less than
13r is overwhelmingly high. Since all equal-size subsets of edges are equally likely to be
chosen, ED (|Cp |+|Cq |) is nonincreasing with the sample size, and so ED (|Cp |+|Cq |) =
O(ED1 (|Cp |+|Cq |)). Let D2 denote the modified distribution used in the calculations.
Observe that D2 is derived from D1 by picking only u if (u, v) is chosen the first time
it is considered for selection and then only v if it is picked the second time around.
By monotonicity, we then have ED1 (|Cp | + |Cq |) = O(ED2 (|Cp | + |Cq |)). This proves
that the O(n/r) bound holds in the original distribution used by the algorithm.
Recall that the running time√is O(r + n/r√+ E (|Cp | + |Cq |)), which is O(r + n/r)
by the above analysis. For r = n
it is O( n).
When the two convex polyhedra intersect, the algorithm reports a point in the
intersection. On the other hand, when they are disjoint, we can report a plane that
separates them. Here is a brief description on how to do that. Note that we cannot
simply return a separating plane for Cp and Cq (or Cp and Cq ) because it is not
necessarily separating for P and √Q. Instead, we resort to geometric duality to compute
the desired plane in expected O( n) time. In a standard geometric duality transform,
a vertex in the primal space is mapped to a plane in the dual space and vice versa.
Moreover, the upper (resp., lower) hull of a convex polyhedron is transformed to a
lower (resp., upper) envelope [13]. When P and Q are disjoint, at least one of the
following must be true: (1) there exists a plane above the upper hull of P and below
634 BERNARD CHAZELLE, DING LIU, AND AVNER MAGEN

the lower hull of Q; (2) there exists a plane below the lower hull of P and above the
upper hull of Q. Since they are symmetric, it suffices to consider the first one. By
duality, such a plane dualizes to a point in the common intersection of an upper and
a lower envelope, which is itself a convex polyhedron. Although this polyhedron is
not available explicitly, we have access to its geometric features (vertices, edges, etc.)
in constant time via the corresponding features
√ in the primal space. Hence we can
apply the above algorithm to find, in O( n) time, an intersection point which is the
dual of a separating plane for P and Q.
It is important to note that an alternative to the above approach can be found in a
general scheme to solve the constant-dimensional LP in linear time due to Clarkson [9].
Clarkson √ suggested a randomized√ algorithm that finds a set of constraints of expected
size O( n) (or, in general, O(d n), where d is the dimension) that contains a “basis,”
that is, a minimal set of constraints that determines the problem. Our approach is
somewhat similar to that schema. Of course, there √ are details to be filled as to how
exactly this set may be computed in time O( n). (Clarkson’s √ algorithm as it is
would be a linear time algorithm.) In particular, an O( n)-time method of finding
the violating subpolyhedron (like the one we proposed) must still be used in order to
implement the alternative approach of Clarkson efficiently enough.
3. Ray shooting applications. Given a convex polyhedron P with n vertices
and a directed line  in R3 , the ray shooting problem asks for the point on (the
boundary of) P hit by  if it exists. We apply essentially the same techniques√ as in
convex polyhedral intersection√to ray shooting and solve it in expected O( n) time.
Choose a random sample of n
edges from P , and let Rp denote the convex√hull
of these edges. We first use an LP to detect intersection of Rp and  in time O( n).
There are two cases. If Rp and  do not intersect, we get a plane L that separates them
and passes through a vertex q of Rp . Starting from q we construct the intersection
Cp of P with the halfspace bounded by L that contains . We already explained
how to do that in the previous section. Finally, we solve ray shooting for Cp and .
Now suppose
√ that Rp and  intersect. We first find the point p on Rp hit by  in
time
√ O( n). We cannot afford to compute an explicit representation of Rp in time
Ω( n log n). To find p we again use an LP. We can assume that  is the positive x-axis
by rotating the coordinate system. Of course, we do not rotate the whole polytope P .
Instead, we maintain such a rotation transform implicitly. In other words, whenever
we need a geometric feature (vertex, edge, etc.) of P after the rotation, we compute
it from its corresponding feature on the original input in constant time. Finding p
is equivalent to finding a plane L such that (1) all vertices of Rp are on one side
of L (the side that contains (+∞, 0, 0)); (2) the intersection point of L with the x-
axis has its x-coordinate as large as possible. In fact, p is that intersection point.
It is straightforward
√ to formulate this problem as a three-dimensional LP and solve
it in time O( n). In particular, to ensure (2) above we minimize the coefficient α
in the equation αx + βy + γz = 1 for L. Once we have L and p, we construct Cp
as before and solve the problem for Cp and . Essentially the √ same analysis as the
proof of Theorem 2.1 shows that the expected size of Cp is O( n). We thus have the
following.
Theorem 3.1. Given a convex polyhedron with n vertices
√ and a directed line, we
can compute their intersection explicitly in optimal O( n ) time.
This sublinear time algorithm for ray shooting towards a convex polyhedron gives
us useful ammunition for all sorts of location problems.
Given the Delaunay triangulation T of a set S of n points in the plane and a
 SUBLINEAR GEOMETRIC ALGORITHMS 635

query point q, consider the problem of locating q, i.e., retrieving the triangle of T
that contains it. The Delaunay triangulation can be given in any classical edge-based
data structure (e.g., DCEL), as long as it supports O(1) time access to a triangle from
a neighboring triangle. We use the close relationship between Delaunay triangulations
and convex hulls given by the mapping h : (x, y) → (x, y, x2 + y 2 ). As is well known,
the Delaunay triangulation of S is facially isomorphic to the lower hull of h(S) (i.e.,
the part of the convex hull that sees z = −∞). In this way, point location in T is
equivalent to ray shooting towards the convex hull, where the ray originates from the
query point q and shoots in the positive z-direction. Obviously, any facial feature of
the convex hull can be retrieved in constant time from its corresponding feature in
the Delaunay triangulation. (The one exception is the set of faces outside the lower
hull: we can simplify matters by adding a dummy vertex to the hull at z = ∞.)
The same argument can be used for point location in Voronoi diagrams. Recall
that each point (px , py ) is now lifted to the plane Z = 2px X + 2py Y − (p2x + p2y ), which
is tangent to the paraboloid Z = X 2 + Y 2 . The Voronoi diagram of S is isomorphic to
the lower envelope of the arrangement formed by the n tangent planes. Note that any
vertex (resp., edge) of the envelope can be derived in constant time from the three
(resp., two) faces incident to the corresponding vertex (resp., edge).
Theorem 3.2. Point location in the Delaunay√triangulation or Voronoi diagram
of n points in the plane can be done in optimal O( n ) time.
Observe that algorithms for computing a Delaunay triangulation or a Voronoi
diagram often supply an efficient point location data structure as a by-product, and
thus sublinear time point location in Delaunay triangulations or Voronoi diagrams
may be of lesser interest. However, our algorithm is still useful when the triangula-
tion/diagram is huge and we cannot afford to store it together with the point location
structure. Our algorithm for point location in Delaunay triangulations also has its
limitations: It works only because of the known correspondence between a Delaunay
triangulation and a special convex polyhedron. It cannot perform point location in ar-
bitrary planar triangulations. In the next section, we use a different method to achieve
sublinear time point location in arbitrary triangulations or convex subdivisions with
O(1) maximum face size.
We consider the following problem, which will arise in our subsequent discussion
of volume approximation and shortest path algorithms. Given a convex polyhedron P
with n vertices and a point q, let nP (q) denote the (unique) point of P that is closest
to q. Of course, we can assume that q does not lie inside P , which we can test by using
the
√ previous algorithm. To compute nP (q) we extract a sample polyhedron Rp of size
n (as we did before) and find nRp (q). Since we just have a collection of vertices
of Rp instead
√ of its full facial representation, it is not obvious how to find nRp (q)
in time O( n). For this purpose, we express this problem as an LP-type problem
and solve it using the method in [5] (see Chapter 8). A reformulation of the problem
would be to seek the plane L that separates q from the vertices of Rp and maximizes
the distance from q to it. To apply the method in [5], we view each vertex of Rp
as a constraint. We also check that all the assumptions (i.e., monotonicity, locality,
violation test, and range space oracle) needed√to solve this problem efficiently hold.
See [5] for details. Thus we get L in time O( n): it is tangent to Rp at nRp (q) and
normal to the segment qnRp (q). Next, we compute the intersection Cp of P with the
halfspace bounded by L √ that contains q. Again, a similar analysis shows that the
expected size of Cp is O( n). Obviously, nP (q) = nCp (q), so we can finish the work
by exhaustive search in Cp .
636 BERNARD CHAZELLE, DING LIU, AND AVNER MAGEN

Theorem 3.3. Given a convex polyhedron √ P with n vertices and a point q, the
nearest neighbor of q in P can be found in O( n ) time.
We can compute a related function by similar means. Given a directed line ,
consider an orthogonal system of coordinates with  as one of its axes (in the positive
direction), and define ξP () to be any point of P with maximum -coordinate. If we
choose a point q at infinity on , then ξP () can be chosen as nP (q), and so we can
apply Theorem 3.3.
Another function we can compute in this fashion maps a plane L and a direction 
in L to the furthest point of P in L along : in other words,
√ ξP (L, ) = ξP∩L (). Again,
the nonobvious part is computing ξRp (L, ) in time O( n) for a sample polytope Rp .
As in the case of ray shooting, we can assume without loss of generality that L is the
xy-plane and  is the positive x-direction. Finding ξRp (L, ) is the same as finding a
plane L such that (1) all vertices of Rp are on one side of L (the side that contains
(−∞, 0, 0)); (2) L is parallel to the y-axis; (3) the intersection point of L with
the√x-axis has its x-coordinate as small as possible. We solve this problem in time
O( n) by formulating it as a three-dimensional LP. Other parts of the algorithm
(e.g., constructing Cp ) and its analysis are similar to other problems discussed in this
section. We summarize our results.
Theorem 3.4. Given a convex polyhedron P with n vertices, √ a directed line ,
and a plane π, the points ξP () and ξP (π, ) can be found in O( n ) time.
4. Point location in convex subdivisions. Given a convex planar subdivision
S with n edges and a query point q, the point location problem √ asks for the face of S
that contains q. In the previous section, we provided an O( n)-time point location
algorithm where S is a Delaunay triangulation or a Voronoi diagram. Devroye, Mücke,
and Zhu [14] also showed that a simple “walk-through” technique locates a query point
in the Delaunay triangulation of n random points in the plane in expected (roughly)
O(n1/3 ) time. Here we show that a slight variation of the walk-through technique
actually locates a query point in any planar√triangulation (not necessarily Delaunay or
formed by random points) in expected O( n) time, which is optimal. Our algorithm
generalizes to planar subdivisions with O(1) maximum face size. We also give a simple
argument showing an Ω(n) lower bound for point location in subdivisions with large
faces.
Theorem 4.1. Point location in an n-edge √ convex planar subdivision with O(1)
maximum face size can be done in optimal O( n ) time.
Proof. First, we consider the case of a triangulation. For an edge e in the tri-
angulation and a query point q, we use qe to denote the nearest neighbor of q on e.
√ to define the Euclidean distance between q and e as |qqe |. We start by
It is natural
sampling n edges of the triangulation at random. Let e be the edge in the random
sample that has the smallest Euclidean distance to q. We walk from qe toward3 q by
traversing all triangles crossed by qqe one by one. Given any edge-based representa-
tion of the triangulation (such as DCEL), it takes constant time to traverse from one
triangle to the next. We stop at the triangle that contains q and output it as the
answer.
The running time (besides the sampling stage) is proportional to the number
of triangles crossed by qqe . Thus it suffices to show that the expected number of
3 It is important to walk towards q from its nearest neighbor on the nearest edge. In contrast,

previous algorithms [27] either walk from an endpoint (or the midpoint) of the nearest edge or
sample by vertices and walk from the nearest sample vertex. These algorithms do not have sublinear
expected running time for arbitrary triangulations.
 SUBLINEAR GEOMETRIC ALGORITHMS 637
√
triangulation edges crossed by qqe is O( n). For this, we rank each edge according
to its Euclidean distance to q. Since the rank of every edge crossed by qqe is smaller
than that of e, the number of edges crossed by qqe is at most the rank√of e. The
claimed time bound then √ follows from the fact that the smallest rank of n random
edges has expectation O( n). It is straightforward to generalize this algorithm to
planar subdivisions with O(1) maximum face size.
What if the subdivision has large faces: Is sublinear time point location still
possible? The answer is no.
Theorem 4.2. There exists an n-edge planar subdivision such that any random-
ized algorithm for point location in this subdivision has expected running time Ω(n).
Proof. Consider the following problem first: We are given a doubly linked list of
numbers. We know exactly one of them is nonzero and want to find out that special
number. We can use an argument similar to the proof of Lemma 1.1 to show that any
randomized algorithm has to spend Ω(n) expected time on this problem. Returning
to point location, consider a rectangle with corners (−1, 0), (−1, n + 1), (1, 0), and
(1, n + 1). By breaking its two vertical sides into n + 1 unit length segments, we get a
face with 2n + 4 edges. Finally, we pick an integer i from 1 to n and add a horizontal
edge from (−1, i) to (1, i). This gives us a two-face subdivision. Given the query
point (0, (n + 1)/2), a deterministic algorithm must find the horizontal edge in the
middle to locate the query correctly, and the only way to do that is through a visit
to one of its four adjacent edges. This is similar in spirit to the list-checking problem
considered above. In other words, in both problems we try to find one of O(1) special
elements in a list4 of size Θ(n). We thus get the same lower bound of Ω(n).
5. Volume approximation. We seek to approximate the volume of a convex
polytope P . We proceed in two stages. First, we compute a large enough enclosed
ellipsoid, which we use to rescale P affinely. This is intended to make P round enough
so that good Hausdorff distance approximation yields good volume approximation.
Second, we use a standard construction of Dudley [16] to find, via the methods of
the previous section, an enclosing polytope of O(1/ε) vertices whose boundary is at
Hausdorff distance at most ε from P . √
Stage 1. We begin by computing, in O( n ) time, a polytope P  ⊆ P , such that

vol (P ) ≥ c0 vol (P ) for some constant c0 > 0. Compute the six points ξP () for
 = ±x, ±y, ±z. These points come in pairs, so let w1 , w2 be the pair forming the
largest distance. Given a point w on the line L passing through w1 and w2 , let Pw
denote the intersection of P with the plane through w that is orthogonal to L. Let
w0 be the midpoint of w1 w2 (Figure 3). We first show that if S is a set of points in
Pw0 such that

(1) area (conv (S)) ≥ c1 area (Pw0 )

for some constant c1 > 0, then vol (conv (S ∪ {w1 , w2 })) ≥ c2 vol (P ) for some other
constant c2 > 0. Therefore, we can take P  = conv (S ∪ {w1 , w2 }) to achieve our
goal. Indeed, assume we have such a set S. As √ a straightforward consequence of
Pythagorean theorem, we find that diam (P ) ≤ 3 d(w1 , w2 ); therefore,√the orthogo-
nal projection of P on L is a segment v1 v2 ⊇ w1 w2 of length at most 3 d(w1 , w2 ).
This implies that, for any w in L, area (Pw ) ≤ 12 area (Pw0 ). To see why, observe that
if, say, w ∈ v1 w0 , then, by convexity, Pw is enclosed in the cone with apex w2 and base
4 In the point location problem there are two lists of vertical edges instead of one. This requires

only a small modification of the argument.

638 BERNARD CHAZELLE, DING LIU, AND AVNER MAGEN

w1 Pw y 1
z1 0

y0
w0
z2 L
y2
w2

Fig. 3. Approximating P from within.

√
Pw0 . Therefore, Pw lies in a copy of Pw0 scaled by at most d(w, w2 )/d(w0 , w2 ) ≤ 2 3,
which proves our claimed upper bound on area  v (Pw ). Of course, the same argument
can be repeated if w ∈ w0 v2 . Since vol (P ) = v12 area (Pw ) dw, we can conclude that
the four quantities

vol (P ), vol (conv (Pw0 ∪ {v1 , v2 })),

vol (conv (Pw0 ∪ {w1 , w2 })), vol (conv (S ∪ {w1 , w2 }))

are all equal up to within constant factors.

We now show how to find a set S satisfying (1). We essentially repeat in two
dimensions what we did so far in three dimensions. Specifically, we take a, b to be two
mutually orthogonal vectors both normal to L, and let π be the plane spanned by a
and b. We compute the four points (two pairs) ξP (π, ) for  = a, −a, b, −b. Let y1 , y2
be the more distant pair (analogous to w1 , w2 before). Let y0 be the midpoint of y1 , y2 ,
and let segment y0 be the intersection of P with the line in π orthogonal to y1 y2 . We
can find the two endpoints z1 , z2 of y0 using ray shooting. Using almost the same
argument as the one showing that conv (Pw0 ∪ {w1 , w2 }) has a volume proportional
to vol (P ), we get that the quadrilateral with vertex set S = {y1 , y2 , z1 , z2 } has an
area proportional to area (Pw0 ), and thus satisfies (1). We comment that a similar
approach to the one we described above was used by Barequet and Har-Peled [4]. The
difference is that they approximate the volume of a convex polytope from outside by
a bounding box, whereas we approximate it from within.
Let E be the largest ellipsoid enclosed in P  = conv ({y1 , y2 , z1 , z2 , w1 , w2 }), also
known as the Löwner–John ellipsoid. It is computable in constant time within any
fixed relative error by solving a constant-size quadratic program [20]. As is well
known, its volume is at least (1/dim)2 times that of the enclosing polytope; therefore,
1
vol (E) ≥ vol (P  ) ≥ c · vol (P )
9
for some constant c > 0. Make the center of the ellipsoid the origin of the system of
coordinates and use the ellipsoid’s positive semidefinite matrix to rescale P . To do
that, we consider the linear transformation that takes the ellipsoid into a ball of the
same volume. Specifically, if xT AT Ax ≤ 1 is the equation of the ellipsoid, then we
consider the transformation T = A/(det A). The polytope T P has the same volume
as P , but it is round; namely, it contains a ball B of volume Ω(vol (T P )). Thus, we
might as well assume that P has this property to begin with. Note that P is also
 SUBLINEAR GEOMETRIC ALGORITHMS 639

enclosed in a concentric ball B  that differs from B by only a constant-factor scaling.

(If not, then T P would contain a point p so far away from B that the convex hull
of p and B, although contained in P , would have volume much larger than vol (B),
and hence vol (P ), which would give a contradiction.) Finally, by rescaling we can
also assume that P is enclosed in the unit ball and its volume is bounded below by a
positive
√ constant. By Theorems 3.1 and 3.4, all of the work in Stage 1 can be done
in O( n ) time.
Stage 2. We implement Dudley’s construction [16] of a convex polytope Q such
that (i) Q ⊇ P ; (ii) Q ⊂ Pε , where Pε is the Minkowski sum of P with a ball of
radius ε; (iii) Q has O(1/ε) vertices. Dudley’s result was used constructively√in [2].
The difference here is that our implementation is sublinear. We compute an ε-net
on the unit sphere,5 and project this net down to ∂P , using the nearest neighbor
function nP as a projection map. Finally, we form Q as the intersection of the
O(1/ε) halfspaces bounded by the appropriate tangent planes passing through the
vertices of the projected net. With suitable use of the nearest neighbor algorithm
√
of Theorem 3.3, we can implement the entire construction in time O(ε−1 n ) for
the projection construction (since the facial representations of P and T P are the
same, the algorithm can use T P as though it had its full facial representation at its
disposal) and O(ε−1 log ε−1 ) for intersecting the halfspaces needed to form Q. Since
we can obviously assume that Q does not have more vertices than P , there is no need
2
for ε to be smaller than, √ say, 1/n . This implies that the entire construction time
−1
is dominated by√O(ε n ). (In fact, we can further reduce this running time to
roughly O(ε−1/2 n ) by exploiting the fact that the O(ε−1 ) nearest neighbor queries
can be answered in a more efficient batch mode. Similarly, we can also get a slight
improvement on the running time in Theorem 6.2.)
We now show that vol (Q) = (1 + O(ε))vol (P ). Recall that P is “sandwiched”
between two concentric balls B and B  such that rad (B  ) = 1 and rad (B) = Ω(1).
We may assume that B and B  are centered at the origin. Since Q ⊂ Pε , we have
vol (Q − P ) ≤ vol (Pε − P ) ≤ area (Pε ) · 2ε ≤ area (B1+2ε ) · 2ε = O(ε), where B1+2ε
is a ball centered at the origin with radius 1 + 2ε. The upper bound on vol (Pε − P )
is obtained by integration over thin shells of increasing area from ∂P to ∂Pε . Since
vol (P ) = Ω(1), we then have vol (Q) = (1 + O(ε))vol (P ).
Theorem 5.1. Given any ε > 0, it is possible to approximate the volume √ of an
n-vertex convex polytope with arbitrary relative error ε > 0 in time O(ε−1 n ).

6. Approximate shortest paths. Given a convex polyhedron P with n vertices

and two points s and t on its boundary ∂P , the problem is to find the shortest
path between s and t outside the interior of P . It is well known that the shortest
path lies on the boundary ∂P . In fact, it is easy to construct instances where any
reasonable approximation of the shortest path on ∂P involves Ω(n) edges. This rules
out sublinear algorithms, unless we are willing to follow paths outside of P . We show
how to compute a path between s and t whose length exceeds the minimum by a
factor of at most 1 + ε for any ε > 0.
Our algorithm relies on a new result of independent interest. Let dP (s, t) denote
the length of the shortest path between s and t in ∂P . Given a point v ∈ ∂P , let Hv
be the supporting plane of P at v (or any such plane if v is a vertex), and let Hv+
denote the halfspace bounded by Hv that contains P . Given ε > 0, we say that a
√
5 This is a collection of O(ε−1 ) points on the sphere such that any spherical cap of radius ε
contains at least one of the points.
640 BERNARD CHAZELLE, DING LIU, AND AVNER MAGEN

convex polytope Q is an ε-wrapper of P if (c0 is an absolute constant discussed below)

(i) Q encloses P ;
(ii) the Hausdorff distance between ∂P and ∂Q is at most ε diam (P );
(iii) given any s, t ∈ ∂P such that dP (s, t) ≥ c0 diam (P ), dQ
(s, t) ≤ (1+ε)dP (s, t),
where Q = Q ∩ H ∩ Ht .
+ +
s
Lemma 6.1. Any convex 3-polytope has an ε-wrapper of size O(1/ε)5/4 for any
ε > 0.
This result improves on the O(1/ε)3/2 bound of Agarwal et al. [2]. The use
of a wrapper is self-evident. First, we clip the polytope to ensure that dP (s, t) ≥
c0 diam (P ) (section 6.1). Next, we compute an ε-wrapper (section 6.2) and approx-
imate the shortest path between s and t by computing the shortest path between
the two points in ∂ Q. This can be done in quadratic time by using an algorithm by
Chen and Han [7]. The resulting path, which is of length (1 + O(ε))dP (s, t), can be
shortened to (1 + ε)dP (s, t) by rescaling ε suitably. Note that in (iii) the condition on
s and t being sufficiently far apart is essential. It is a simple exercise to show that no
variant of a wrapper can accommodate all pairs (s, t) simultaneously. If f (n) denotes
the complexity of the exact version of problem, then we have the following.
Theorem 6.2. Given any ε > 0 and two points s, t on the boundary of a convex
polytope P of n vertices, it is possible to find√a path between s and t outside P of
length at most (1 + ε)dP (s, t) in time O(ε−5/4 n ) + f (ε−5/4 ).
We refer the reader back to the introduction for a discussion of the implication
of this result in view of the state-of-the-art on the function f (n).
6.1. Computing short paths. Given two points s, t ∈ ∂P , our first task is
to ensure that dP (s, t) ≥ c0 diam (P ) for some constant c0 > 0. To do this, we
first compute a value δ such that δ ≤ dP (s, t) ≤ 8δ. We will substitute for P the
intersection P  of P with a clipping box centered at s of side length 16δ. Obviously,
the shortest paths between s and t relative to P and P  are identical. The only
computational primitive we need is the nearest neighbor function of Theorem 3.3.
Note that we need only this function relative to P (not to P  ). In fact, we first use
this function to compute a few sample points on ∂P (see section 6.2). We then discard
sample points that are outside of the clipping box. The remaining points together
with the clipping box are used to compute an ε-wrapper of P  .
To compute a constant-factor approximation for dP (s, t), we adapt an algorithm
of Har-Peled [21] to our sublinear setting. All that is needed is an implementation
of the following primitive: Given two rays r1 , r2 from a fixed point p ∈ P , let H be
the plane spanned by these two rays, and let C denote the two-dimensional cone in
H wedged between r1 and r2 . Given an additional query ray r ∈ H (not necessarily
emanating √ from p), we need to compute ξC∩P (H, r). By Theorem 3.4, this can be
done in O( n ) time.
6.2. The ε-wrapper construction. Assuming without loss of generality that
diam (P ) = 1, it suffices to prove the following.
Theorem 6.3. Given any ε > 0 and a convex polytope P of n vertices with
diameter 1, there exists a convex polytope Q with O(ε−5/4 ) vertices such that (i)
Q ⊇ P ; (ii) the Hausdorff distance between ∂P and ∂Q is O(ε); and (iii) given any
s, t ∈ ∂P such that dP (s, t) ≥ c0 for some constant c0 , dQ
(s, t) ≤ (1 + O(ε))dP (s, t),

where Q = Q ∩ Hs ∩ Ht .
+ +

We first show how to construct Q. Let S be a sphere of radius 2 centered at

some arbitrary point in P . Draw a grid G of longitudes and latitudes on S, so that
 SUBLINEAR GEOMETRIC ALGORITHMS 641

Fig. 4. The grid G.

q2

p
p m–1
q1 2
q m–1

p pm
1

Fig. 5. The path σ.

√ √
each cell is √
of length ε by ε (with an exception made for the last latitude and
longitude if ε does not divide π). All lengths in this discussion are Euclidean, except
in this case where the length of a circular arc refers to its corresponding angle. We
choose a parameter λ = ε3/4 and subdivide √ each side of a cell into subarcs of length
λ (Figure 4). In this way√each cell has O( ε/λ) vertices, and the whole construction
defines a set V of O(1/λ ε ) vertices. For each point v ∈ V , we compute nP (v), its
nearest neighbor in ∂P , and define

(2) Q= { Hn+P (v) | v ∈ V }.

It is immediate from our choice of λ that Q has O(ε−5/4 6

√ ) vertices. Every point of the
sphere S has at least one vertex of G at distance O( ε ). By a result of Dudley [16],
this implies part (ii) of Theorem 6.3. Since (i) is obvious, it remains for us to prove
(iii).
Borrowing terminology from Agarwal et al. [2], we say that a pair (σ, H) forms a
supported path of P if σ = p1 ,q1 ,p2 ,q2 ,. . ., qm−1 ,pm is a polygonal line disjoint from
the interior of P and H = Hp1 , . . . , Hpm is a sequence of supporting planes of P , such
that qi−1 pi and pi qi both lie in Hpi , with q0 = p1 and qm = pm (Figure 5). For
0 < i < m, the folding angle αi at qi is the dihedral angle of the wedge between Hpi
and Hpi+1 (the one that does not contain P ). The folding angle of σ is defined as
α(σ) = 0<i<m αi .
Lemma 6.4 (Agarwal et al. [2]). Given s, t ∈ ∂P , there exists a supported path
σ of P with O(1/ε) edges, joining s and t, such that

dP (s, t) ≤ |σ| ≤ (1 + ε)dP (s, t) and α(σ) = O(ε−1/2 ).

6 To be precise, we actually want to compute an ε-wrapper for P  instead of P . For this, we need

to remove from the point set V all vertices whose nearest neighbors in ∂P fall outside of the clipping
box in section 6.1. We also need to clip Q by that box. We omit these minor details.
642 BERNARD CHAZELLE, DING LIU, AND AVNER MAGEN

To help build intuition for the remainder of our discussion, it is useful to sketch
the proof of the lemma. Mapping the grid G to P via the nearest neighbor function nP
creates a grid nP (G) on ∂P (with curved, possibly degenerate edges). It is convenient
to think of P as a smooth manifold by infinitesimally rounding the vertices and edges.
It does not much matter how we do that, as long as the end result endows each point
p ∈ ∂P with an (outward) unit normal vector ηp that is a continuous function of p.
Note that in this way, for any u ∈ S, the vectors unP (u) and ηnP (u) are collinear,
and the function nP is a bijection. The fundamental property of the nearest neighbor
function is that it is nonexpansive. We need only a weak version of that fact, which
follows directly from Lemmas 4.3 and 4.4 in [16].
Lemma 6.5 (Dudley [16]). Given two points p, q ∈ ∂P , |pq| and  (ηp , ηq ) are
both in O( |n−1 −1
P (p)nP (q)| ).
This implies that, for any two points p, √q ∈ ∂P in the same cell of the mapped grid
nP (G), both |pq| and  (ηp , ηq ) are in O( ε ). We shortcut the shortest path on ∂P
from s to t to form a supported path σ that passes through each cell at most once. In
this manner, we identify O(1/ε) points p1 , . . . , pm on ∂P , where pi (resp., pi+1 ) is the
entry (resp., exit) point of the path through the ith cell in the sequence. The points
pi lie on the edges of nP (G). There are two exceptions, p1 = s and pm = t, which
might lie in the interior of the cell. Next, we connect each pair (pi , pi+1 ) by taking
the shortest path on Hpi ∪ Hpi+1 . The path intersects Hpi ∩ Hpi+1 at a point denoted
qi . (Note that qi might be infinitesimally close to pi .) This forms a supported path
σ with O(1/ε) vertices s = p1 , q1 , p2 , q2 , . . . , qm−1 , pm = t. The only real difference
from the proof in [2] is that we skip the final “trimming” step and keep the points pi
unchanged. We mention two useful, immediate √ consequences of Lemma 6.5.
• The folding angle at qi is O( ε ).
• For each 1 ≤ i ≤ m, the point pi belongs to ∂P and, for i = 1, m, there exists
a point wi = nP (vi ), where vi ∈ V , such that both |pi wi | and  (ηpi , ηwi ) are
in O(λ).
From σ we build a curve σ  of length (1 + O(ε))|σ| that joins s and t outside the
interior of Q.  The classical result below shows that the shortest path on ∂ Q  from s

to t cannot be longer than σ , which proves Theorem 6.3.
Theorem 6.6 (Pogorelov [29]). Given a convex body C, let γ be a curve joining
two points s, t ∈ ∂C outside the interior of C. Then the length of γ is at least that of
the shortest path joining s and t on ∂C.
We now explain how to construct σ  . For 0 < i < m, let (pi , ηpi ) and (qi , ηpi )
be the rays emanating from pi and qi , respectively, in the direction normal to Hpi
away from P . Together with the segments pi qi and qi pi+1 , the four rays (pi , ηpi ),
(qi , ηpi ), (qi , ηpi+1 ), and (pi+1 , ηpi+1 ) define a polyhedral surface Σi , which consists of
two unbounded rectangles, Σ1i and Σ3i , joined together at qi by an unbounded triangle,
Σ2i (Figure 6). Note that the surface is in general nonplanar, but Σ2i is always normal
to the line Hpi ∩Hpi+1 . Out of Σi we carve a polyhedral strip Si as follows. Fix a large
enough constant c > 0, and let Ki denote the plane Hpi + cλ2 ηpi . In other words, Ki
is a parallel copy of Hpi translated by cλ2 away from P . As usual, the superscripted
Ki+ denotes the halfspace enclosing P . Recall that wi is the nearest neighbor of vi
defined earlier. We need to consider

Si = Σi ∩ (Ki+ ∩ Ki+1 +
) ∪ (Hw+i ∩ Hw+i+1 ) .

Again, we have two exceptions for i = 1, m − 1, where we use Hp+1 instead of Hw+1 and
 SUBLINEAR GEOMETRIC ALGORITHMS 643

2
1 Σi
Σi Σi
3

q i/ q i/ /

p/
i+1
p/ qi
i
2
p Cλ
pi
i+1

Fig. 6. The curve σi .

x
y
O
p

Hp

Fig. 7. How Hp intersects the xz plane.

Hp+m instead of Hw+m .

Let pi pi be the edge of Si incident to pi collinear with
ηpi . We denote by σi


the portion of ∂Si between pi and pi+1 and define σ  as 0<i<m σi . To provide a
connection to s and t, we also add to σ  the segments p1 p1 and pm pm . To show that
σ  is a connected curve outside the interior of Q  of length (1 + O(ε))|σ| requires a
simple technical lemma.
Lemma 6.7 (Figure 7). Given an orthogonal system of reference (O, xyz), assume
that P is tangent to the xy-plane at O and lies below it. Given a point p on ∂P , if
|n−1 −1
P (O)nP (p)| < δ, for some small enough δ > 0, then the intersection of Hp with
the xz-plane has for an equation Z = aX + b, where |a| = O(δ) and 0 ≤ b = O(δ 2 ).
Proof. By Lemma 6.5, the normal to Hp forms a small angle θ = O(δ) with
the z-axis, so the plane Hp , being nonparallel to the z-axis, can be expressed as
Z = aX + cY + b. The cross product between the normal (a, c, −1) and the z-
axis
√ vector is the vector (c, √ −a, 0). By the cross product formula, its length, which is
a2 + c2 , is also equal to a2 + c2 + 1 sin θ. It follows that a2 +c2 = O(a2 +c2 +1)δ 2 ;
therefore,
O(δ 2 )
(3) a2 + c2 = = O(δ 2 ),
1 − O(δ 2 )
and hence |a| = O(δ). By convexity of P , the plane Hp intersects the nonnegative part
of the z-axis, and pz , the z-coordinate of p, is nonpositive. By (3) and |Op| = O(δ),
it follows that
 
0 ≤ b = pz − apx − cpy ≤ a2 + c2 p2x + p2y = O(δ 2 ).

We examine each σi separately, omitting the cases i = 1, m − 1, which are trivial
644 BERNARD CHAZELLE, DING LIU, AND AVNER MAGEN

modifications of the general case 1 < i < m − 1. The curve σi lies outside the interior
of Hw+i ∩ Hw+i+1 , and hence of Q.  It is naturally broken up into three parts, σ j ⊂ Σj
i i
(j = 1, 2, 3), each one of them being a polygonal curve whose edges lie in any one of
four planes: Ki , Ki+1 , Hwi , and Hwi+1 . Applying Lemma 6.7 with (pi , − → −−→
p−
i qi , pi pi ) in
the role of (O, x, z) and wi in the role of p, we find that Hwi intersects the segment
pi pi for c large enough (note that this c is the one in the definition of Ki ); similarly,
Hwi+1 intersects pi+1 pi+1 . This shows that pi is the intersection of the ray (pi , ηpi )
with the plane Ki ; therefore, pi is the same point in the definition of σi and σi−1 
, thus
 
proving that the curve σ is, indeed, connected. (The danger was having pi defined
by Hwi+1 .) We now bound the length of σi .
• By√Lemma 6.7 the slopes of the edges√of σi1 are chosen among 0 for Ki ;
O( ε ) for Ki+1 ; O(λ) for √ Hwi ; and O( ε ) for Hwi+1 . It follows that |σi1 | ≤
|pi qi |/ cos θ, where θ = O( ε ); therefore, |σi1 | = (1 + O(ε))|pi qi |. The same
argument shows that |σi3 | = (1 + O(ε))|qi pi+1 |.
• Let qi , qi be the endpoints of the curve σi2 (Figure 6), and let a, a , b, b be
the distances along the ray (qi , ηpi ) from qi to Ki , Ki+1 , Hwi , and Hwi+1 ,
respectively. By definition of Si ,

|qi qi | = max min{a, a }, min{b, b } .

Obviously, a = cλ2 and, by Lemma 6.7, b = O(λ|pi qi | + λ2 ). This implies

that |qi qi | = O(λ|pi qi | + λ2 ) and, by the same argument,

|qi qi | + |qi qi | = O(λ(|pi qi | + |qi pi+1 |) + λ2 ).

Within Σ2i , the curve σi2 is a polygonal line consisting of at most a constant
number of edges. It is not difficult to see that for any vertex v of σi2 (including √
qi and qi ), the angle between qi v and edges of σi2 incident to v is π/2±O( ε ).
This follows from a simple geometric observation: given any plane H whose
normal makes with qi v an angle at most α, the angle formed by qi v and any
line on H lies in the range [π/2 − α, π/2 + α]. Since any of the edges of σi2
lies on one of four planes, Ki , K √i+1 , Hwi , and Hwi+1 , and the normal of each
of them makes an √ angle of O( ε) with qi v, the claim follows. Because the
folding angle of O( ε ) can be assumed to be less than, say, π/2, this implies
that the curve σi2 lies entirely√at a distance O(|qi qi |+|qi qi |) from qi . It follows
that |σi2 | = O(|qi qi | + |qi qi |) ε.
Putting everything together we find that
√ √
|σi | = (1 + O(ε) + O(λ ε ))(|pi qi | + |qi pi+1 |) + O(λ2 ε ).

In view of the fact that |p1 p1 | = |pm pm | = cλ2 , summing up over all |σi |’s (there are
O(1/ε) of them),
√ √
|σ  | = (1 + O(ε) + O(λ ε ))|σ| + O(λ2 / ε )
= (1 + O(ε))|σ| + O(ε)
= (1 + O(ε))|σ|,

which completes the proof of Theorem√ 6.3. Note that the setting of λ is made to
ensure that the additive term O(λ2 / ε ) is O(ε).
 SUBLINEAR GEOMETRIC ALGORITHMS 645

Acknowledgments. We wish to thank Pankaj Agarwal, Funda Ergun, Sariel

Har-Peled, Joe Mitchell, and Ronitt Rubinfeld for several helpful discussions. We
also wish to thank the anonymous referees for their comments and suggestions.

REFERENCES

[1] P. K. Agarwal, S. Har-Peled, and M. Karia, Computing approximate shortest paths on

convex polytopes, Algorithmica, 33 (1999), pp. 227–242.
[2] P. K. Agarwal, S. Har-Peled, M. Sharir, and K. Varadarajan, Approximating shortest
paths on a convex polytope in three dimensions, J. ACM, 44 (1997), pp. 567–584.
[3] P. K. Agarwal and J. Erickson, Geometric range searching and its relatives, in Advances in
Discrete and Computational Geometry, B. Chazelle, J. E. Goodman, and R. Pollack, eds.,
Contemp. Math. 223, AMS, Providence, RI, 1999, pp. 1–56.
[4] G. Barequet and S. Har-Peled, Efficiently approximating the minimum-volume bounding
box of a point set in three dimensions, J. Algorithms, 38 (2001), pp. 91–109.
[5] B. Chazelle, The Discrepancy Method: Randomness and Complexity, Cambridge University
Press, Cambridge, UK, 2000.
[6] B. Chazelle and D. P. Dobkin, Intersection of convex objects in two and three dimensions,
J. ACM, 34 (1987), pp. 1–27.
[7] J. Chen and Y. Han, Shortest paths on a polyhedron, in Proceedings of the Sixth Annual
Symposium on Computational Geometry, ACM, New York, 1990, pp. 360–369.
[8] K. L. Clarkson and P. W. Shor, Applications of random sampling in computational geom-
etry, II, Discrete Comput. Geom., 4 (1989), pp. 387–421.
[9] K. L. Clarkson, Las Vegas algorithms for linear and integer programming when the dimension
is small, J. ACM, 42 (1995), pp. 488–499.
[10] A. Czumaj, F. Ergun, L. Fortnow, A. Magen, I. Newman, R. Rubinfeld, and C. Sohler,
Sublinear-time approximation of Euclidean minimum spanning tree, in Proceedings of the
Fourteenth Annual Symposium on Discrete Algorithms, ACM, New York, 2003, pp. 813–
822.
[11] A. Czumaj and C. Sohler, Property testing with geometric queries, in Proceedings of the
9th Annual European Symposium on Algorithms, Springer-Verlag, Heidelberg, 2001, pp.
266–277.
[12] A. Czumaj, C. Sohler, and M. Ziegler, Property testing in computational geometry, in
Proceedings of the 8th Annual European Symposium on Algorithms, Springer-Verlag, Hei-
delberg, 2000, pp. 155–166.
[13] M. de Berg, M. van Kreveld, M. Overmars, and O. Schwarzkopf, Computational Geom-
etry: Algorithms and Applications, Springer-Verlag, Berlin, 1997.
[14] L. Devroye, E. P. Mücke, and B. Zhu, A note on point location in Delaunay triangulations
of random points, Algorithmica, 22 (1998), pp. 477–482.
[15] D. P. Dobkin and D.G. Kirkpatrick, Determining the separation of preprocessed polyhedra—
a unified approach, in Automata, Languages and Programming, Springer-Verlag, New York,
1990, pp. 400–413.
[16] R. M. Dudley, Metric entropy of some classes of sets with differentiable boundaries, J. Approx.
Theory, 10 (1974), pp. 227–236.
[17] D. Eppstein, Dynamic Euclidean minimum spanning trees and extrema of binary functions,
Discrete Comput. Geom., 13 (1995), pp. 111–122.
[18] F. Ergun, S. Kannan, Kumar, S. Ravi, R. Rubinfeld, and M. Viswanathan, Spot-checkers,
J. Comput. System Sci., 60 (2000), pp. 717–751.
[19] B. Gärtner and E. Welzl, A simple sampling lemma: Analysis and applications in geometric
optimization, Discrete Comput. Geom., 25 (2001), pp. 569–590.
[20] M. Grötschel, L. Lovász, and A. Schrijver, Geometric Algorithms and Combinatorial
Optimization, Springer-Verlag, Berlin, 1988.
[21] S. Har-Peled, Approximate shortest-path and geodesic diameter on convex polytopes in three
dimensions, Discrete Comput. Geom., 21 (1999), pp. 217–231.
[22] S. Kapoor, Efficient computation of geodesic shortest paths, in Proceedings of the 31st Annual
Symposium on Theory of Computing, ACM, New York, 1999, pp. 770–779.
[23] J. Matoušek, Geometric range searching, ACM Comput. Surv., 26 (1994), pp. 421–461.
[24] K. Mehlhorn, S. Naher, T. Schilz, S. Schirra, M. Seel, R. Seidel, and C. Uhrig, Check-
ing geometric programs or verification of geometric structures, Comput. Geom., 12 (1999),
pp. 85–103.
[25] J. S. B. Mitchell, D. M. Mount, and C. H. Papadimitriou, The discrete geodesic problem,
646 BERNARD CHAZELLE, DING LIU, AND AVNER MAGEN

SIAM J. Comput., 16 (1987), pp. 647–668.

[26] J. S. B. Mitchell, An algorithmic approach to some problems in terrain navigation, in Au-
tonomous Mobile Robots: Perception, Mapping and Navigation, IEEE Computer Society
Press, Los Alamitos, CA, 1991, pp. 408–427.
[27] E. P. Mücke, I. Saias, and B. Zhu, Fast randomized point location without preprocessing in
two and three-dimensional Delaunay triangulations, Comput. Geom., 12 (1999), pp. 63–83.
[28] K. Mulmuley, Output sensitive and dynamic constructions of higher order Voronoi diagrams
and levels in arrangements, J. Comput. System Sci., 47 (1993), pp. 437–458.
[29] A. V. Pogorelov, Extrinsic geometry of convex surfaces, Transl. Math. Monogr. 35, AMS,
Providence, RI, 1973.
[30] D. Ron, Property testing, in Handbook on Randomization, Vol. II, S. Rajasekaran, P. M.
Pardalos, J. H. Reif, and J. D. P. Rolim, eds., Kluwer Academic Publishers, Dordrecht,
The Netherlands, 2001, pp. 597–649.
[31] R. Seidel, Small-dimensional linear programming and convex hulls made easy, Discrete Com-
put. Geom., 6 (1991), pp. 423–434.
[32] M. Sharir and A. Schorr, On shortest paths in polyhedral spaces, SIAM J. Comput., 15
(1985), pp. 193–215.
[33] A. C. Yao, Probabilistic computations: Towards a unified measure of complexity, in Proceed-
ings of the 18th Annual Foundations of Computer Science, IEEE Computer Society Press,
Los Alamitos, CA, 1977, pp. 222–227.