Chen, Computational Geometry Methods and Applications

Computational Geometry:
Methods and Applications

Jianer Chen
Computer Science Department
Texas A&M University
February 19, 1996
Chapter 1
Introduction
Geometric objects such as points, lines, and polygons are the basis of a
broad variety of important applications and give rise to an interesting set
of problems and algorithms. The name geometry reminds us of its earliest
use: for the measurement of land and materials. Today, computers are being
used more and more to solve larger-scale geometric problems. Over the past
two decades, a set of tools and techniques has been developed that takes
advantage of the structure provided by geometry. This discipline is known
as Computational Geometry.
The discipline was named and largely started around 1975 by Shamos,
whose Ph.D. thesis attracted considerable attention. After a decade of devel-
opment the eld came into its own in 1985, when three components of any
healthy discipline were realized: a textbook, a conference, and a journal.
Preparata and Shamos's book Computational Geometry: An Introduction
[23], the rst textbook solely devoted to the topic, was published at about
the same time as the rst ACM Symposium on Computational Geometry was
held, and just prior to the start of a new Springer-Verlag journal Discrete and
Computational Geometry. The eld is currently thriving. Since 1985, sev-
eral texts, collections, and monographs have appeared [1, 10, 18, 20, 25, 26].
The annual symposium has attracted 100 papers and 200 attendees steadily.
There is evidence that the eld is broadening to touch geometric modeling
and geometric theorem proving. Perhaps most importantly, the rst students
who obtained their Ph.D.s in computer science with theses in computational
geometry have graduated, obtained positions, and are now training the next
generation of researchers.
Computational geometry is of practical importance because Euclidean
1
2 INTRODUCTION
space of two and three dimensions forms the arena in which real physical
objects are arranged. A large number of applications areas such as pattern
recognition [28], computer graphics [19], image processing [22], operations
research, statistics [4, 27], computer-aided design, robotics [25, 26], etc., have
been the incubation bed of the discipline since they provide inherently geo-
metric problems for which ecient algorithms have to be developed. A large
number of manufacturing problems involve wire layout, facilities location,
cutting-stock and related geometric optimization problems. Solving these
eciently on a high-speed computer requires the development of new geo-
metrical tools, as well as the application of fast-algorithm techniques, and
is not simply a matter of translating well-known theorems into computer
programs. From a theoretical standpoint, the complexity of geometric algo-
rithms is of interest because it sheds new light on the intrinsic diculty of
computation.
In this book, we concentrate on four major directions in computational
geometry: the construction of convex hulls, proximity problems, searching
problems and intersection problems.
Chapter 2
Algorithmic Foundations
For the past twenty years the analysis and design of computer algorithms
has been one of the most thriving endeavors in computer science. The funda-
mental works of Knuth [14] and Aho-Hopcroft-Ullman [2] have brought order
and systematization to a rich collection of isolated results, conceptualized
the basic paradigms, and established a methodology that has become the
standard of the eld. It is beyond the scope of this book to review in detail
the material of those excellent texts, with which the reader is assumed to
be reasonably familiar. It is appropriate however, at least from the point of
view of terminology, to brie y review the basic components of the language
in which computational geometry will be described. These components are
algorithms and data structures. Algorithms are programs to be executed on
a suitable abstraction of actual \von Neumann" computers; data structures
are ways to organize information, which, in conjunction with algorithms,
permit the ecient and elegant solution of computational problems.
2.1 A Computational model

Many formal models of computation appear in the literature. There is no
general consensus as to which of these is the best. In this book, we will
adopt the most commonly-used model. More specically, we will adopt
random access machines (RAM) as our computational model.
3
4 ALGORITHMIC FOUNDATIONS
Random access machine (RAM)
A random access machine (RAM) models a single-processor computer with
a random access memory.
A RAM consists of a read-only input tape, a write-only output tape, a
program and a (random access) memory. The memory consists of registers
each capable of holding a real number of arbitrary precision. There is also
no upper bound on the memory size. All computations take place in the
processor. A RAM can access (read or write) any register in the memory in
one time unit when it has the correct address of that register.
The following operations on real numbers can be done in unit time by a
random access machine :
1) Arithmetic operations: , =, +, ?, log, exp, sin.
2) Comparisons
3) Indirect access
2.2 Complexity of algorithms and problems

The following notations have become standard:
O(f (n)) : the class C1 of functions such that for any g 2 C1, there is a
constant cg such that f (n) cg g (n) for all but a nite number of n's.
Roughly speaking, O(f (n)) is the class of functions that are at most
as large as f (n).
o(f (n)) : the class C2 of functions such that for any g 2 C2,
limn!1 g (n)=f (n) = 0. Roughly speaking, o(f (n)) is the class of func-
tions that are less than f (n).

(f (n)) : the class C3 of functions such that for any g 2 C3, there is a
constant cg such that f (n) cg g (n) for all but a nite number of n's.
Roughly speaking,
(f (n)) is the class of functions which are at least
as large as f (n).
!(f (n)) : the class C4 of functions such that for any g 2 C4,
limn!1 f (n)=g (n) = 0. Roughly speaking, ! (f (n)) is the class of
functions that are larger than f (n).
(f (n)) : the class C5 of functions such that for any g 2 C5, g(n) =
O(f (n) and g(n) =
(f (n)). Roughly speaking, (f (n)) is the class
of functions which are of the same order as f (n).
DATA STRUCTURE 5
Complexity of algorithms
Let A be an algorithm implemented on a RAM. If for an input of size n, A
halts after m steps, we say that the running time of the algorithm A is m
on that input.
There are two types of analyses of algorithms: worst case and expected
case. For the worst case analysis, we seek the maximum amount of time used
by the algorithm for all possible inputs. For the expected case analysis we
normally assume a certain probabilistic distribution on the input and study
the performance of the algorithm for any input drawn from the distribu-
tion. Mostly, we are interested in the asymptotic analysis, i.e., the behavior
of the algorithm as the input size approaches innity. Since expected case
analysis is usually harder to tackle, and moreover the probabilistic assump-
tion sometimes is dicult to justify, emphasis will be placed on the worst
case analysis. Unless otherwise specied, we shall consider only worst case
analysis.
Denition Let A be an algorithm. The time complexity of A is O(f (n))

if there exists a constant c such that for every integer n 0, the running
time of A is at most c f (n) for all inputs of size n.
Complexity of problems
While time complexity for an algorithm is xed, this is not so for problems.
For example, Sorting can be implemented by algorithms of dierent time
complexity. The time complexity of a known algorithm for a problem gives us
the information about at most how much time we need to solve the problem.
We would also like to know the minimum amount of time we need to solve
the problem.
Denition A function u(n) is an upper bound on the time complexity of a

problem P if there is an algorithm A solving P such that the running time
of A is u(n). A function l(n) is a lower bound on the time complexity of a
problem P if any algorithm solving P has time complexity at least l(n).
2.3 A data structure supporting set operations
A set is a collection of elements. All elements of a set are dierent, which
means no set can contain two copies of the same element.
When used as tools in computational geometry, elements of a set usually
are normal geometric objects, such as points, straight lines, line segments,
and planes in Euclidean spaces.
We shall sometimes assume that elements of a set are linearly ordered
by a relation, usually denoted \<" and read \less than" or \precedes". For
example, we can order a set of points in the 2-dimensional Euclidean space
by their x-coordinates.
Let S be a set and let u be an arbitrary element of a universal set of which
S is a subset. The fundamental operations occurring in set manipulation are:
MEMBER(u; S ): Is u 2 S ?
INSERT(u; S ): Add the element u to the set S .
DELETE(u; S ): Remove the element u from the set S .
When the universal set is linearly ordered, the following operations are very
important:
MINIMUM(S ): Report the minimum element of the set S .
SPLIT(u; S ): Partition the set S into two sets S1 and S2, so that S1
contains all the elements of S which are less than or equal to u, and
S2 contains all the elements of S which are larger than u.
SPLICE(S; S1; S2): Assuming that all elements in the set S1 are less
than any element in the set S2 , form the ordered set S = S1 [ S2.
We will introduce a special data structure: 2-3 trees, which represent
sets of elements and support the above set operations eciently.
Denition A 2-3 tree is a tree such that each non-leaf node has two or
three children, and every path from the root to a leaf is of the same length.
The proof of the following theorem is straightforward and left to the

reader.
DATA STRUCTURE 7
Theorem 2.3.1 A 2-3 tree of n leaves has height O(log n).
A linearly ordered set of elements can be represented by a 2-3 tree by
assigning the elements to the leaves of the tree in such a way that for any
non-leaf node of the tree, all elements stored in its rst child are less than
any elements stored in its second child, and all elements stored in its second
child are less than any elements stored in its third child (if it has a third
child).
Each non-leaf node v of a 2-3 tree keeps three pieces of information for
the corresponding subtree.
L(v) : the largest element stored in the subtree rooted at its rst child.
M (v) : the largest element stored in the subtree rooted at its second
child.
H (v) : the largest element stored in the subtree rooted at its third
child (if it has one).
2.3.1 Member
The algorithm for deciding the membership of an element in a 2-3 tree is
given as follows, where T is a 2-3 tree, t is the root of T , and u is the element
to be searched in the tree.
Algorithm MEMBER(T, u)
BEGIN
IF T is a leaf node then report properly
ELSE IF L(t) >= u then MEMBER(child1(T), u)
ELSE IF M(t) >= u then MEMBER(child2(T), u)
ELSE IF t has a third child
THEN MEMBER(child3(T), u)
ELSE report failure.
END
Since the height of the tree is O(log n), and the algorithm simply follows a
path in the tree from the root to a leaf, the time complexity of the algorithm
MEMBER is O(log n).
2.3.2 Insert
To insert a new elment x into a 2-3 tree, we proceed at rst as if we were
testing membership of x in the set. However, at the level just above the
leaves, we shall be at a node v that should be the parent of x. If v has only
two children, we simply make x the third child of v , placing the children in
the proper order. We then adjust the information contained by the node v
to re ect the new situation.
Suppose, however, that x is the fourth child of the node v . We cannot
have a node with four children in a 2-3 tree, so we split the node v into two
nodes, which we call v and v 0 . The two smallest elements among the four
children of v stay with v , while the two larger elements become children of
node v 0 . Now, we must inset v 0 among the children of p, the parent of v .
The problem now is solved recursively.
One special case occurs when we wind up splitting the root. In that case
we create a new root, whose two children are the two nodes into which the
old root was split. This is how the number of levels in a 2-3 tree increases.
The above discussion is implemented as the following algorithms, where
T is a 2-3 tree and x is the element to be inserted.
Algorithm INSERT(T, x)
BEGIN
1. Find the proper node v in the tree T such that
v is going to be the parent of x;
2. Create a leaf node d for the element x;
3. ADDSON(v, d)
END
Where the procedure ADDSON is implemented by the following recursive

algorithm, which adds a child d to a non-leaf node v in a 2-3 tree.
Algorithm ADDSON(v, d)
BEGIN
1. IF v is the root of the tree, add the node d properly.
Otherwise, do the following.
2. IF v has two children, add d directly
3. ELSE
3.1. Suppose v has three children c1, c2, and c3. Partition c1,
DATA STRUCTURE 9
c2, c3 and d properly into two groups (g1, g2) and (g3, g4).
Let v be the parent of (g1, g2) and create a new node v' and
let v' be the parent of (g3, g4).
3.2. Recursively call ADDSON(father(v), v').
END
Analysis: The algorithm INSERT can nd the proper place in the tree for
the element x in O(log n) time since all it needs to do is to follow a path
from the root to a leaf. Step 2 in the algorithm INSERT can be done in
constant time. The call to the procedure ADDSON in Step 3 can result in
at most O(log n) recursive calls to the procedure ADDSON since each call
will jump at least one level up in the 2-3 tree, and each recursive call takes
constant time to perform Steps 1, 2, and 3.1 in the algorithm ADDSON. So
Step 3 in the algorithm INSERT takes also O(log n) time. Therefore, the
overall time complexity of the algorithm INSERT is O(log n).
2.3.3 Minimum
Given a 2-3 tree T we want to nd out the minimum element stored in
the tree. Recall that in a 2-3 tree the numbers are stored in leaf nodes
in ascending order from left to right. Therefore the problem is reduced to
going down the tree, always selecting the left most link, until a leaf node is
reached. This leaf node should contain the minimum element stored in the
tree. Evidently, the time complexity of this algorithm is O(log n) for a 2-3
tree with n leaves.
Algorithm MINIMUM(T, min)
BEGIN
IF T is a leaf THEN
min := T;
ELSE call MINIMUM(child1(T), min);
END
2.3.4 Delete
When we delete a leaf from a 2-3 tree, we may leave its parent v with only
one child. If v is the root, delete v and let its lone child be the new root.
Otherwise, let p be the parent of v . If p has another child, adjacent to v on
either the right or the left, and that child of p has three children, we can
transfer the proper one of those three to v . Then v has two children, and we
are done.
If the children of p adjacent to v have only two children, transfer the lone
child of v to an adjacent sibling of v , and delete v . Should p now have only
one child, repeat all the above, recursively, with p in place of v .
Summarizing these discussions together, we get the algorithm DELETE,
as shown below. Where procedure DELETE() is merely a driver for sub-
procedure DEL() in which the actual work is done.
The variables done and 1son in DEL() are boolean ags used to indicate
successful deletion and to detect the case when a node in the tree has only
one child, respectively.
In the worst case we need to traverse a path in the tree from root to a
leaf to locate the node to be deleted, then from that leaf node to the root,
in case that every non-leaf node on the path has only two children in the
original 2-3 tree T . Thus the time complexity of DELETE algorithm for a
tree with n nodes is O(log n).
Algorithm DELETE(T, x)
BEGIN
Call DEL(T, x, done, 1son);
IF done is true THEN
IF 1son is true THEN T := child1(T)
ELSE x was not found in T, handle properly
END
Algorithm DEL(T, x, done, 1son)
BEGIN
1. IF children of T are leaves THEN process properly, i.e., if
x is found, delete it; update the variables done and 1son;
2. ELSE IN CASE OF
x <= L(T): son := child1(T);
L(T) < x <= M(T): son := child2(T);
M(T) < x <= H(T): son := child3(T);
3. Call DEL(son, x, done, 1son1);
4. IF 1son1 is true THEN
4.1. IF the node T has another child b that has three children,
THEN reorganize the grandchildren among the nodes son and
DATA STRUCTURE 11
b to make both have two children, and set 1son := false;
4.2. ELSE make the only child of the node son a child of a
sibling of it, and delete the node son from T. If T has
only one child then set 1son := true.
END
2.3.5 Splice
Splicing two trees into one big tree is a special case of the more general
operation of merging two trees. Splice assumes that all the keys in one of the
trees are larger than all those in the other tree. This assumption eectively
reduces the problem of merging the trees into \pasting" the smaller tree into
a proper position in the larger tree. \Pasting" the smaller tree is actually
no more than performing an ADDSON operation to a proper node in the
larger tree.
To be more specic, let T1 and T2 be 2-3 trees which we wish to splice into
the 2-3 tree T , where all keys in T1 are smaller than those in T2. Furthermore,
assume that the height of T1 is less than or equal to that of T2 so that T1 is
\pasted" to T2 as a left child of a leftmost node at the proper level in T2. In
the case where the heights are equal, both T1 and T2 are made children of
the common root T ; otherwise the proper level in T2 is given by
height(T2) ? height(T1) ? 1
It is clear that the algorithm SPLICE runs in time O(log n). In fact,
the running time is proportional to the height dierence height(T2) ?
height(T1) ? 1.
The implementation of the algorithm SPLICE is given below.
Algorithm SPLICE(T, T1, T2)
{ Suppose that all elements in T1 are less than any elements in T2,
and that the height of T1 is at most that of T2. Other cases can
be dealt with similarly.}
BEGIN
IF height(T1) = height(T2)
THEN make T a parent of T1 and T2.
ELSE
WHILE height(T2)-1 > height(T1) DO
T2 := child1(T2)
Call ADDSON(T2, T1).
END
2.3.6 Split
By splitting a given 2-3 tree T into two 2-3 trees, T1 and T2, at a given
element x, we mean to split the tree T in such a way that all elements in T
that are less than or equal to x go to T1 while the remaining elements in T
go to T2 .
The idea is as follows: as the tree is searched for x, we store the subtrees
to the left and right of the traversed path (split path). For this purpose two
stacks are used, one for each side of the split path. As we go deeper into
T , subtrees are pushed into the proper stack. Finally, the subtrees in each
stack are spliced together to form the desired trees T1 and T2, respectively.
The algorithm is given as follows.
Algorithm SPLIT(T, x, T1, T2)
{Split T into T1 and T2 such that all elements in T1 are less

than or equal to x, and all elements in T2 are greater than x.
The stacks S1 and S2 are used to store the subtrees to the left
and right of the path in the 2-3 tree T from the root to the
leaf x, respectively.}
BEGIN
1. WHILE T is not leaf DO
IF x <= L(T) THEN
S2 <-- child3(T), child2(T);
T := child1(T);
IF L(T) < x <= M(T) THEN
S1 <-- child1(T); S2 <-- child3(T);
T := child2(T);
IF M(T) < x <= H(T) THEN
S1 <-- child1(T), child2(T);
T := child3(T);
{Reconstruct T1}
2. T1 <-- S1;
3. WHILE S1 is not empty DO
t <-- S1;
Call SPLICE(T1, t, T1);
DATA STRUCTURE 13
{Reconstruct T2}
4. T2 <-- S2;
5. WHILE S2 is not empty DO
t <-- S2;
Call SPLICE(T2, T2, t);
END
It is easy to see that the WHILE loop in Step 1 takes time O(log n). The
analysis for the rest of the algorithm is a bit more complicated. Note that
the use of the stacks S1 and S2 to store the subtrees guarantees that the
height of a subtree closer to a stack top is less than or equal to the height of
the subtree immediately deeper in the stack. A crucial observation is that
since we splice shorter trees rst (which are on the top part of the stacks),
the dierence between the heights of two trees to be spliced is always very
small. In fact, the total time spent on splicing all these subtrees is bounded
by O(log n). We give a formal proof as follows.
Assume that the subtrees stored in stack S1 are
t1; t2; ; tr (2:1)
in the order from the stack top to stack bottom. Let h(t) be the height of
the 2-3 tree t. According to the algorithm SPLIT, we have
h(t1) h(t2 ) h(tr )
and no three consecutive subtrees in the stack have the same height. Thus,
we can partition sequence (1) into \segments" which contains the subtrees
of the same height in the sequence:
s1 ; s2; ; sq
Each si either is a single subtree or consists of two consecutive subtrees of
the same height in sequence (1). Moreover, q log n. Let h(si ) be the
height of the subtrees contained in the segment si . We have
h(s1 ) < h(s2) < < h(sq )
The WHILE loop in Step 3 rst splices the subtrees in segment s1 into
a single 2-3 tree T1(1), then recursively splices the 2-3 tree T1(i?1) and the
subtrees in segment si into a 2-3 tree T1(i), for i = 2; : : :; q . We have the
following lemma.
Lemma 2.3.2 For all i = 2; : : :; q, we have
h(si?1 ) h(T1(i?1)) h(si) < h(si+1 ) < < h(sq )
proof. That h(s1 ) h(T1(1)) is fairly clear since T1(1) is obtained by

splicing subtrees in the segment s1 . For i > 2, since T1(i?1) is obtained by
splicing the tree T1(i?2) and the subtrees in si?1 , and the subtrees in si?1 have
height h(si?1 ). Thus, the height of the 2-3 tree T1(i?1) is at least h(si?1 ).
Now we prove the rest inequalities.
Since the 2-3 tree T1(1) is obtained by splicing the subtrees in the segment
s1 , and segment s1 contains at most two subtrees, both of height h(s1 ). Thus,
the height of the 2-3 tree T1(1) is at most h(s1 ) + 1, which is not larger than
h(s2 ). Thus, the lemma is true for the case i = 2.
Now assume that the lemma is true for the case i ? 1,
h(T1(i?1)) h(si ) < h(si+1 ) < < h(sq )
We consider the height of the 2-3 tree T1(i) .
If the segment si is a single subtree ti of height h(si ), then splicing the
tree T1(i?1) of height at most h(si ) and the tree ti of height h(si ) results in
a 2-3 tree T1(i) of height at most h(si ) + 1, which is not larger than h(si+1 ).
Now suppose that the segment si consists of two subtrees t0i and t00i of
height h(si ). Since the height of the tree T1(i?1) ) is at most h(si ) by the
inductive hypothesis, splicing the trees T1(i?1)) and t0i results in a 2-3 tree T 0
of height at most h(si ) + 1. Moreover, according the algorithm SPLICE, if
the height of T 0 is h(si ) + 1, then the root of T 0 has only two children. Now
splice the trees T 0 and t00i into the 2-3 tree T1(i): If the height of the tree T 0
is smaller than h(si ) + 1, then splicing T 0 and the subtree t00i of height h(si )
results in a tree T1(i) of height at most h(si ) + 1, which is not larger than
h(si+1 ). On the other hand, if the height of the tree T 0 is h(si) + 1, then
the root of T 0 has only two children, thus splicing T 0 and t00i will not create
a new root and the resulting tree T1(i) has height h(si ) + 1, again not larger
than h(si+1 ). This concludes that we always have
h(T1(i)) h(si+1 ) < h(si+2 ) < < h(sq )
This completes the induction proof and shows the correctness of the
lemma.
GEOMETRIC GRAPHS 15
Now we are ready for the following theorem
Theorem 2.3.3 The WHILE loop in Step 3 of the algorithm SPLIT takes
time O(log n).
proof. First we study the complexity of constructing the 2-3 tree T1(i)
from the 2-3 tree T1(i?1) and the trees in the segment si . According to
Lemma 2.3.2, we have
h(T1(i?1)) h(si )
Thus, if si is a single subtree ti , then according the analysis of the time
complexity of the algorithm SPLICE, the time of splicing T1(i?1) and ti is
bounded by a constant times
h(si ) ? h(T1(i?1))
On the other hand, if si consists of two subtrees t0i and t00i , then the
time for splicing T1(i?1) and t0i is again bounded by a constant times h(si ) ?
h(T1(i?1) ). Moreover, note that the height of the resulting tree T 0 from
splicing T1(i?1) and t0i is either h(si ) or h(si ) + 1, and that the height of
the subtree t00i is h(si ). Thus, splicing T 0 and t00i takes only constant time.
Therefore, in this case, the total time to construct T1(i) from T1(i?1) and si is
bounded by a constant times
h(si ) ? h(T1(i?1)) + 1
Therefore, to construct the nal 2-3 tree T1(q), the total time of the
WHILE loop in Step 3 is bounded by a constant times
X
q
(h(si ) ? h(T1(i?1)) + 1)
i=2
By Lemma 2.3.2, we have h(si?1 ) h(T1(i?1)). Thus, the time complexity
of the WHILE loop in Step 3 is bounded by a constant times
X
q
(h(si ) ? h(si?1 ) + 1)
i=2
which is equal to h(sq ) ? h(s1 ) + q . Since all quantities h(sq ), h(s1 ), and
q are bounded by log n, we conclude that the WHILE loop in Step 3 takes
time O(log n).
The same proof shows that the WHILE loop in Step 5 also takes time
O(log n). In conclusion, the algorithm SPLIT takes time O(log n).
2.4 Geometric graphs in the plane
A graph G = (V; E ) is planar if it can be embedded in the plane without
edge crossings.
A planar embedding of a planar graph G = (V; E ) is a mapping of each
vertex in V to a point in the plane and each edge in E to a simple curve
between the two images of extreme vertices of the edge, so that no two images
of edges intersect except at their endpoints. The image of the mapping is
called a geometric graph in the plane.
If all edges of a geometric graph G are straight-line segments in the plane,
G is called a planar straight-line graph, or PSLG. A PSLG G determines in
general a subdivision of the plane. Each region R of the subdivision, together
with the edges of G that are on the boundary of R, forms a polygon in the
plane.
Euler's formula
Let v; e and f denote the number of vertices, edges and regions (including
the unbounded region) of a PSLG, respectively. The famous Euler's formula
relates these parameters by
v?e+f = 2
if we have an additional property that each vertex has degree at least 3
then we can prove the following relations:
v 23 e
e 3f ? 6
f 32 e
v 2f ? 4
e 3v ? 6
f 2v ? 4
That is, we have
(v ) = (e) = (f )
Therefore, for a planar graph, the number of vertices, the number of edges,
and the number of regions are all linearly related.
GEOMETRIC GRAPHS 17
v1
f4
e1 e3
f1 f2 e2
e4 v4 e5
f3
v2 e6 v3
Figure 2.1: The planar imbedding of K4
Doubly Connected Edge List (DCEL)

Given a planar imbedding I of the complete graph K4, as depicted in Fig-
ure 2.1, what information should we keep for this imbedding? Of course, the
set of vertices, and the set of edges of K4 should be kept. Moreover, it is
also necessary to keep the information about the regions of the imbedding I .
To represent the information of the regions, we must know which edge will
follow which edge when we travel around a vertex counterclockwise, i.e., we
must know the cyclic ordering for the edges incident on each vertex of the
imbedding I .
The Doubly Connected Edge List (DCEL) is an ecient data structure
to represent a PSLG. The main component of DCEL for a PSLG G is the
edge node. There is a one-to-one correspondence between the edges of G
and edge nodes in the corresponding DCEL. An edge node consists of four
information elds V 1; V 2; F 1 and F 2, and two pointer elds P 1 and P 2.
The elds V 1 and V 2 contain the starting vertex and ending vertex of the
edge, respectively. (So we give each edge of the PSLG G an orientation.
This orientation can be dened arbitrarily.) The elds F 1 and F 2 contain
the names of the regions which lie respectively to the left and right of the
edge oriented from V 1 to V 2. The pointer P 1 (or P 2) points to the edge
node containing the rst edge encountered after the edge (V 1; V 2) when one
proceeds counterclockwise around V 1 (or V 2). Therefore, the edge P 1 is the
edge following the edge (V 1; V 2) at the vertex V 1, while the edge P 2 is the
edge following the edge (V 1; V 2) at the vertex V 2 in the imbedding I (G).
The following is the DCEL for the PSLG, which is the complete graph
K4 in Figure 2.1.
V1 V2 F1 F2 P1 P2
e1 v2 v1 f4 f1 e6 e3
e2 v1 v3 f4 f2 e1 e5
e3 v1 v4 f2 f1 e2 e4
e4 v4 v2 f3 f1 e5 e1
e5 v3 v4 f3 f2 e6 e3
e6 v2 v3 f3 f4 e4 e2
Note that the space used by a DCEL to represent a PSLG is linear to
the number of edges of the PSLG.
Suppose that the set of vertices of a PSLG G is fv1; ; vn g, and the set
of regions of G is ff1 ; ; fmg. We have another two arrays HV [1::n] and
HF [1::m], where HV [i] points to an edge node in the DCEL such that one
edge end of the corresponding edge is vi , for i = 1; ; n, and HF [j ] points
to an edge node on the DCEL such that the corresponding edge is on the
boundary of the region fj , for j = 1; ; m.
Using DCEL of G we can travel the boundary of each region of G or the
edges incident on a vertex of G. The following is an algorithm for traveling
the boundary of a region when the DCEL of G is given. (The algorithm for
traveling the edges incident on a vertex of G is given in [23].)
Algorithm TRACE-REGION(i)
{ Trace the boundary edges of the region i. }
BEGIN
1. a := HF[i];
2. a0 := a;
3. IF (DCEL[a][F1] = i) THEN
a := DCEL[a][P1];
ELSE a := DCEL[a][P2];
4. WHILE (a <> a0) DO
IF (DCEL[a][F1] = i) THEN
a := DCEL[a][P1]
ELSE a := DCEL[a][P2];
END.
GEOMETRIC GRAPHS 19
For example, if we start with HF [3] = 4, and use the DCEL for the
planar imbedding I of the complete graph K4, then we will get the region
f3 as e4 , e5 , and e6.
Note that if the rotation of edges incident on each vertex of the PSLG G
is given in counterclockwise order in a DCEL, then the regions are traveled
clockwise by the above algorithm. On the other hand, if the rotation of edges
incident on each vertex of the PSLG G is given in clockwise order in a DCEL,
then the regions are traveled counterclockwise by the above algorithm. Given
a PSLG G, it is easy to see that a DCEL for G in which the rotation of
edges incident on each vertex of G is given in counterclockwise order can be
transformed in linear time into a DCEL for G in which the rotation of edges
incident on each vertex of G is given in clockwise order, and vice versa. The
detailed implementation of this transformation is straightforward and left to
the reader as an exercise.
Chapter 3
Geometric Preliminaries
According to the nature of the geometric objects involved, we can identify
basically ve categories into which the entire collection of geometric problems
can be conveniently classied, i.e., convexity, proximity, geometric searching,
intersection, and optimization.
In this chapter, we will give the precise denitions of these problems
and give an \intuitive" discussion on the mathematical background of them.
Some of our statements and proofs are informal. This is because of the fact
that some geometric theorems are \intuitively obvious" but no easy proofs
are known though many great mathematicians have tried. An example is
the following famous \Jordan Curve Theorem", which will actually serve as
a fundamental basis for all of our discussions.
Jordan Curve Theorem Let C be a simple closed curve in the

plane, then the plane is subdivided into an interior region and an
exterior region such that every curve connecting a point in the
interior region and a point in the exterior region must intersect
the curve C .
The k-dimensional Euclidean space E k is the space of all k-tuples

(x1 ; ; xk ) of real numbers xi , 1 i k. The distance between two points
p1 = (x1; ; xk) and p2 = (y1; ; yk ) in the k-dimensional space is dened
by
1=2
X
k
2
d(p1; p2) = ( jyi ? xij )
i=1
21
22 GEOMETRIC PRELIMINARIES
The line passing through the points p1 and p2 can be parameterized by
p1 + (1 ? )p2
where ranges over the reals. If we restrict to the interval [0, 1], then we
have a representation for a line segment, denoted p1 p2, with the points p1
and p2 as its extreme points.
More generally, suppose k + 1 independent points p0 , p1 , , pk belong
to a k-dimensional hyperplane. Then the hyperplane is parameterized by
0p0 + 1p1 + + k pk
P
where ki=0 i = 1. If we further restrict all i 0, then we have the
representation for a simplex on k + 1 points.
Given a triangle with edges A, B and C , the angle between the two
edges B and C can be obtained by the following formula:
2 2 2
= arccos jBj 2+ jjBCjj j?C jjAj (3:1)
where jAj, jB j, and jC j denote the lengths of the edges A, B , and C , respec-
tively.
Suppose that is a triangle in the plane E 2 with the vertices p1 =
(x1 ; y1), p2 = (x2; y2) and p3 = (x3 ; y3). Then the signed area of is half of
the determinant
x1 y1 1
D(p1; p2; p3) = x2 y2 1 (3:2)
x 3 y3 1
where the sign is positive if (p1p2 p3) form a counterclockwise cycle, and
negative if (p1 p2p3 ) form a clockwise cycle. We say that the path from point
p1 through the line segment p1 p2 to point p2 then through the line segment
p2p3 to point p3 is a left turn if D(p1; p2; p3) is positive, otherwise, we say
the path makes a right turn.
With the formulas (8.1) and (8.3), given three points p1 , p2, and p3 in
the plane E 2, we can determine completely the value of the angle from the
line segment p1p2 to the line segment p1p3 (denote this angle by 6 p2 p1p3 ).
A line L on the plane can be represented by a linear equation:
Ax + By + C = 0
CONVEX HULLS 23
such that a point p = (x; y ) is on the line if and only if the coordinates of p
satisfy the equation. A half plane dened by the line L can be represented
by either
Ax + By + C 0
or
Ax + By + C 0
3.1 Convex hulls

A subset L E k is a convex set if for every pair p1 , p2 of points in L, the
line segment p1p2 is entirely in L.
Theorem 3.1.1 The intersection of convex sets is convex.
proof. Let Si , i = 1; 2; ; be convex sets. Denote by S the intersection
of all these Si's. We prove that S is again convex.
Let p1 and p2 be two points in S . Since S is the intersection of all Si 's,
p1 and p2 are also points in each set Si , i = 1; 2; . Since each Si is convex,
by denition, the entire line segment p1p2 is in Si , for i = 1; 2; , thus in
the intersection S of all these Si's.
Denition Let L E k . The convex hull CH(L) of L is the smallest

convex set containing L.
Given n points in the plane, we want to nd their convex hull. This
problem is as fundamental to computational geometry as sorting to general
algorithms. It is also a vehicle for the solution of a number of apparently
unrelated questions arising in computational geometry. The construction of
the convex hull of a nite set of points has also found applications in many
areas, such as in pattern recognition, in image processing, in Robotics, and
in stock cutting and allocation.
Theorem 3.1.2 Let L E k . The convex hull CH(L) of L equals the inter-
section of all convex sets containing L in E k .
proof. Let S be the intersection of all convex sets containing L in E k .
By theorem 3.1.1, S is convex, and obviously contains L. Now we prove that
S is the smallest such set. Let S 0 be an arbitrary convex set containing L.
Then by the denition of S , S is the intersection of S 0 and other convex sets
containing L, therefore, S is a subset of S 0. That is, S is contained in every
convex set containing L, so S is the smallest such set.
A polygon in E k is a nite set of line segments satisfying the following
two conditions:
1. every endpoint is shared by exactly 2 line segments; and
2. no proper subset has Property 1.
Now we study our problems in the plane E 2, i.e., the 2-dimensional
Euclidean space.
Given a polygon P in the plane E 2, P is a simple polygon if there is no
pair of nonconsecutive edges sharing a point. For any simple polygon in the
plane, we can apply the Jordan Curve Theorem to divide the plane into the
interior and the exterior of the simple polygon. For a simple polygon P ,
we will use P to refer to either the boundary of P , or the boundary plus
the interior of P . The reader should not be confused from the contents.
A polygon P is called a convex polygon if P is a simple polygon and the
boundary plus the interior of P is a convex set in E 2.
Theorem 3.1.3 The convex hull of a nite set S of points in E 2 is a simple
polygon. Moreover, each hull vertex must be a point in the set S .
proof. We give an informal, but intuitive proof here. A formal proof can
be found in [17].
1. The convex hull CH(S) of the nite set S must be connected. Other-
wise, let p1 and p2 be two points in two distinct connected components
of CH(S). Then the line segment p1 p2 would not be entirely in CH(S).
2. The convex hull CH(S) must be a bounded area. In fact, since S
consists of nite number of points, we must be able to draw a circle C
of a nite radius in the plane such that all points of S are inside C .
The circle C is obviously convex. Now by denition, the convex hull
CH(S) is contained in the circle C .
3. Let p1 and p2 be two points in S such that all points of S are on
one side of the straight line through p1 and p2 , then the line segment
CONVEX HULLS 25
p1p2 is on the boundary of the convex hull CH(S). First of all, the line
segment p1p2 must be contained in CH(S). Moreover, since the half
plane H1 determined by the straight line through points p1 and p2 and
containing all points of S is a convex set containing the set S , so the
convex hull CH(S) is contained in H1 . Therefore, no point on the other
side of the line segment p1 p2 can be in CH(S). That is, p1 p2 is on the
boundary of the convex hull CH(S).
4. All points on the boundary of CH(S) must be on a line segment p1 p2 ,
where p1 and p2 are points in the set S . Suppose that p is not such
a point and p is on the boundary of CH(S). If we \slightly" move the
part of the boundary of CH(S) near the point p so that the resulting
area is properly contained in CH(S), is still convex, and contains all
points in the set S , then we get a convex set that contains all points
of the set S , and is \smaller" than CH(S), contradicting the denition
of convex hulls.
Therefore, the boundary of the convex hull CH(S) must consist of a
nite set G of line segments of which the end-points are points in the set
S . Suppose that a line segment p1 p2 is on the boundary of CH(S). Without
loss of generality, we can suppose that the points of the set S are on our left
when we travel along the straight line L through p1 and p2 in the direction
from p1 to p2 . Now if we rotate the line L counterclockwise around the point
p2 , the line L will eventually hit a rst point p3 of the set S . It is obvious
to see that now the line segment p2 p3 is also on the boundary of CH(S).
Moreover, there is no other point p in S that can make the line segment p2p
on the boundary of CH(S) if we assume that no three points in the set S are
co-linear (the proof can be modied properly for the general case), since the
points p1 and p3 must lie on dierent sides of the straight line through p2 p.
Now based on the new line and the hull vertex p3, we can nd the next hull
vertex, etc.. This process must be stopped eventually since there are only
nite number of points in the set S . Therefore, we will eventually hit a point
p in the set S that has been decided earlier to be a hull vertex. The point p
must be the point p1 since all other hull vertices found have already had the
two line segments incident on them, which are on the boundary of CH(S).
Therefore, we have enclosed the points of the set S by a closed simple cycle,
which is a simple polygon P = fp1 ; p2; ; pk g. No point p in the interior of
P can be on the boundary of CH(S) since any straight line through the point
p will intersect with a boundary edge of the polygon P , thus have points in
the set S on both of its sides. Therefore, the simple polygon P is the convex
hull CH(S).
3.2 Proximity problems

The examples of proximity problems include CLOSEST-PAIR, ALL-
NEAREST-NEIGHBORS, EUCLIDEAN-MINIMUM-SPANNING-TREE,
TRIANGULATION, and MAXIMUM-EMPTY-CIRCLE.
Proximity problems arise in many applications where physical or math-
ematical objects are represented as points in space. Examples include the
following:
clustering: a number of entities are grouped together if they are suf-
ciently close to one another;
classication: a new pattern to be classied is assigned to the class of
its closest (classied) neighbor; and
air-trac control: the two airplanes that are closest are the two most
in danger.
We will restrict ourselves to 2-dimensions. The input to these problems
is a set S of n points in the plane. The distance between points in S will be
the Euclidean distance between the points.
CLOSEST-PAIR
Find a pair of points in the set S which are closest.
ALL-NEAREST-NEIGHBORS
For every point in the set S , nd a point that is nearest to it.
EUCLIDEAN-MINIMUM-SPANNING-TREE
Find an interconnecting tree of minimum total length whose vertices
are the points in the set S .
TRIANGULATION
Join the points in the set S by non-intersecting straight line segments
so that every region interior to the convex hull of S is a triangle.
PROXIMITY PROBLEMS 27
p
i
p
H(p , pj ) j
i
Figure 3.1: The points that are closer to pi than to pj
MAXIMUM-EMPTY-CIRCLE
Find a largest circle containing no points of the set S yet whose center
is interior to the convex hull of S .
The problems posed above are related in the sense that they all deal with
the respective distances among points in the plane. In the following, we will
introduce a single geometric structure, called the Voronoi diagram, which
contains all of the relevant proximity information in only linear space.
Let us get some motivation from the CLOSEST-PAIR problem. Let S
be a set of n points in the plane. For any two points pi and pj in S , the set of
points closer to pi than to pj is just the half-plane containing pi that is dened
by the perpendicular bisector of the segment pi pj . See Figure 3.1. Denote
this half-plane by H (pi; pj ) (note that H (pi; pj ) 6= H (pj ; pi)). Therefore, the
set Vi of points in the plane that are closer to the point pi than to any other
points in the set S is the intersection of the sets H (pi; pj ) for all pj 2 S ?fpi g
\
Vi = j 6=i H (pi; pj )
Each H (pi; pj ) is a half-plane so it is convex. By Theorem 3.1.1, the set
Vi, which is the intersection of these convex sets H (pi; pj ), is also convex. It
is also easy to see that the set Vi is in fact a convex polygonal region. Observe
that every point in the plane must belong to some region Vi . Moreover, no
set Vi can be empty since all points in a small enough disc centered at the
point pi must be in Vi.
Thus these n convex polygonal regions V1, V2, , Vn partition the plane
into a convex net. Motivated by this discussion, we introduce the following
denition.
Denition A Voronoi diagram of a set S = fp1; ; png of n planar points
is a partition of the plane into n regions V1, V2, , Vn such that any point
in the region Vi is closer to the point pi than to any other point in the set
S.
The convex polygonal region Vi is called the Voronoi polygon of the point
pi in S . The vertices of the diagram are called Voronoi vertices and the line
segments of the diagram are called Voronoi edges. The Voronoi diagram of
a set S is denoted by Vor(S). Note that Voronoi vertices are in general not
the points in the set S .
3.3 Intersections
Intersection problems and their variations arise in many disciplines, such as
architectural design, computer graphics, pattern recognition, etc. An archi-
tectural design cannot place two interpenetrable objects to share a common
region. When displaying objects on a 2-dimensional display device, obscured
portions (or intersecting portions) should be eliminated to enhance realism,
a long standing problem known as hidden line/surface elimination problem
[19]. In integrated circuit design two distinct components must be separated
by a certain distance, and the detection of whether or not the separation
rule is obeyed can be cast as an instance of intersection problems; since the
task may involve thousands of objects, fast algorithms for detecting or re-
porting intersecting or overlapping objects are needed. Another motivation
for studying the complexity of intersection algorithms is that light may be
shed on the inherent complexity of fundamental geometric problems. For
example, how dicult is it to decide if a given polygon with n vertices is
simple or how much time is needed to determine if any two of n given objects
in the plane, such as polygons, line segments, etc., intersect?
We list a few typical geometric intersection problems.
SEGMENT INTERSECTION
SEARCHING 29
Given n line segments in the plane, nd all intersections.
HALF-PLANE INTERSECTION
Given n half-planes in the plane, compute their common intersection.
POLYGON INTERSECTION
Given two polygons P and Q with m and n vertices, respectively, com-
puter their intersection.
3.4 Geometric searching

This geometric problem is well motivated by the following Post Oce Prob-
lem proposed by Knuth [14]: Given a xed map of n post oces, for an
arbitrary query point, which is the nearest post oce? The solution to this
problem is simple: compare the distance between the query point and each
post oce and nd the nearest one. The time complexity of this algorithm
is obviously O(n). It is also easy to see that to nd the nearest post oce, at
least n comparisons are needed, since if the algorithm does not compute the
distance between the query point and some post oce, then we are always
able to construct an input instance such that the query point is closest to the
uncompared post oce so that the algorithm outputs an incorrect answer.
Therefore, for a single query point, the above simple algorithm is actually
optimal.
On the other hand, suppose that we have, say, n query points and we
are asking the nearest post oce for each query point. If we again apply
the above algorithm, then it takes time O(n) to nd the nearest post oce
for each query point, so totally we need time O(n2) to nd the nearest post
oces for all query points. Now it seems that the time O(n2 ) is not necessary.
For example, after we have computed the distance between the rst query
point and each of the post oce and found the nearest post oce for the
rst query point, it seems that we can save some information about the post
oces and use this information to speed up the computation of nearest post
oce for the latter query points. Even more cleverly, we can rst organize
the post oces into an easy-search structure such that searching the nearest
post oce for each query point can be done very eciently on the organized
structure.
One candidate of these smart structures is the Voronoi diagram, intro-
duced in Section 2.2. Given n post oces, regarding them as a set S of n
points in the plane, we rst construct the Voronoi diagram Vor(S) for the
set S . Then nding the nearest post oce for a query point is reduced to
locating the query point in a Voronoi polygon of Vor(S).
This is a typical geometric searching problem, called point location prob-
lem: Suppose that we have a subdivision G of the plane and we want to know
in which region of G a given query point is located. In the simplest case, we
have only one query point. Then we can search the point in each region of
G directly to nd the region containing the point. A one-time query of this
type is called single shot. However, we may have many query points and
want to nd the containing region for each query point. Such queries are
called repetitive-mode queries.
In the case of repetitive-mode queries, it may be worthwhile to arrange
the subdivision G into a more organized structure to facilitate searching.
Therefore, when we are considering the problem of repetitive-mode queries,
we are interested in three computational resources: the preprocessing time
that is used to convert the given subdivision G into an organized structure,
the storage that is used to store the organized structure, and the query time
that is needed to locate each query point.
Suppose that the input subdivision G has n vertices. In general, we
cannot expect that the preprocessing time is less than O(n) since even read-
ing the input subdivision G takes time
(n). Similarly, we cannot expect
that the storage used for the organized structure is less than O(n) since
even storing the unorganized structure, the subdivision G itself needs
(n)
space. Finally, as pointed out by Knuth [14], any algorithm for searching
an ordered table of length n by means of comparisons can be represented
as a binary tree of n leaves, thus in the worst case, the searching time is at
least
(log n). While the point location problem is clearly a generalization
of searching, we conclude that the query time of the point location problem
is at least
(log n).
Chapter 4
Geometric Sweeping
Geometric sweeping technique is a generalization of a technique called plane
sweeping, that is primarily used for 2-dimensional problems. In most cases,
we will illustrate the technique for 2-dimensional cases. The generalization
to higher dimensions is straightforward. This technique is also known as the
scan-line method in computer graphics, and is used for a variety of applica-
tions, such as shading, polygon lling, among others.
The technique is intuitively simple. Suppose that we have a line in the
plane. To collect the geometric information we are interested in, we slide
the line in some way so that the whole plane will be \scanned" by the line.
While the line is sweeping the plane, we stop at some points and update our
recording. We continue this process until all interesting objects are collected.
There are two basic structures associated with this technique. One is for
the sweeping line status, which is an appropriate description of the relevant
information of the geometric objects at the sweeping line, and the other is
for the event points, which are the places we should stop and update our
recording. Note that the structures may be implemented in dierent data
structures under various situations. In general, the data structures should
support ecient operations that are necessary for updating the structures
while the line is sweeping the plane.
4.1 Intersection of line segments

The geometric sweeping technique can be best illustrated by the following
example. Recall the SEGMENT INTERSECTION problem:
Given n line segments in the plane, nd all intersections.
31
32 GEOMETRIC SWEEPING
Suppose that we have a vertical line L. We sweep the plane from left
to right. At every moment, the sweeping line status contains all segments
intersecting the line L, sorted by the y -coordinates of their intersecting points
with L. The sweeping line status is modied whenever one of the following
three cases occurs:
1. The line L hits the left-end of a segment S . In this case, the segment S
was not seen before and it may have intersections with other segments
on the right side of the line L, so the segment S should be added to
the sweeping line status;
2. The line L hits the right-end of a segment S . In this case, the segment
S cannot have any intersections with other segments on the right side
of the line L, so the segment S can be deleted from the sweeping line
status;
3. The line L hits an intersection of two segments S1 and S2 . In this
case, the relative positions of the segments S1 and S2 in the sweeping
line status should be swapped, since the segments in the sweeping line
status are sorted by the y -coordinates of their intersection points with
the line L.
It is easy to see that the sweeping line status of the line L will not be
changed when it moves from left to right unless it hits either an endpoint
of a segment or an intersection of two segments. Therefore, the set of event
points consists of the endpoints of the given segments and the intersection
points of the segments. We sort the event points by their x-coordinates.
We use two data structures EVENT and STATUS to store the event
points and the sweeping line status, respectively, such that the set opera-
tions MINIMUM, INSERT, and DELETE can be performed eciently (for
example, they can be 2-3 trees). At very beginning, we suppose that the line
L is far enough to the left so that no segments intersect L. At this moment,
the sweeping line status is an empty set. We sort all endpoints of the seg-
ments by their x-coordinates and store them in EVENT. These are the event
points at which the line L should stop and update the sweeping line status.
However, the list is not complete since an intersection point of two segments
should also be an event point. Unfortunately, these points are unknown to
we at beginning. For this, we update the structure EVENT in the following
way. Whenever we nd an intersection point of two segments while the line
L is sweeping the plane, we add the intersection point to EVENT. But how
SEGMENT INTERSECTION 33
do we nd these intersection points? Note that if the next event point to be
hit by the sweeping line L is an intersection point of two segments S1 and
S2 , then the segments S1 and S2 should be adjacent in the sweeping line
status. Therefore, whenever we change the adjacency relation in STATUS,
we check for intersection points for new adjacent segments. When the line
L reaches the left-most endpoint of the segments, all possible intersection
points are collected.
These ideas are summarized by the following algorithm.
Algorithm SEGMENT-INTERSECTION
Given: n segments S1, S2, ... Sn

Output: all intersections of these segments
{ Implicitly, we use a vertical line L to sweep the plane. At any

moment, the segments intersecting L are stored in STATUS, sorted
by the y-coordinates of their intersection points with the line
L. The event points stored in EVENT are sorted by their x-coor-
dinates }
BEGIN
1. Sort the endpoints of the segments and put them in EVENT;
2. STATUS = {};
3. WHILE EVENT is not empty DO BEGIN
p = MINIMUM(EVENT);
DELETE p from EVENT;
IF p is a right-end of some segment S
Let Si and Sj be the two segments adjacent to S in STATUS;
IF p is an intersection point of S with Si or Sj
REPORT(p);
DELETE S from STATUS;
IF Si and Sj intersect at p1 and x(p1) >= x(p)
INSERT p1 into EVENT
ELSE IF p is a left-end of some segment S
INSERT S into STATUS;
Let Si and Sj be the adjacent segments of S in STATUS;
IF p is an intersection point of S with Si or Sj
REPORT(p);
IF S intersects Si at p1, INSERT p1 into EVENT;
IF S intersects Sj at p2, INSERT p2 into EVENT
ELSE IF p is an intersection point of segments Si and Sj
such that Si is on the left of Sj in STATUS
REPORT(p);
swap the positions of Si and Sj in STATUS;
Let Sk be the segment left to Sj and let Sh be the segment
right to Si in STATUS;
IF Sk and Sj intersect at p1 and x(p1) > x(p)
INSERT p1 into EVENT;
IF Sh and Si intersect at p2 and x(p2) > x(p)
INSERT p2 into EVENT;
END; {WHILE}
END.
Let us analyze the algorithm. Step 1, sorting the 2n endpoints of the

segments, can be done in time O(n log n), if we employ an ecient sorting
algorithm, for example, the MergeSort. Step 2 takes constant time O(1). To
count the time spent by the WHILE loop, suppose there are m intersection
points for these n segments. In the WHILE loop, each segment is inserted
then deleted from the structure STATUS exactly once, and each event point
is inserted then deleted from the structure EVENT exactly once. There are
n + m event points. If we suppose that the operations MINIMUM, INSERT,
and DELETE can all be done in time O(log N ) on a set of N elements, then
processing each segment takes at most O(log n) time, and processing each
event point takes at most O(log(n + m)) time. Therefore, the algorithm runs
in time
O(n log n) + O(1) + n O(log n) + (n + m) O(log(n + m))

= O((n + m) log(n + m))
Observe that m is at most n2 , so log(n + m) = O(log n). Thus we

conclude that the algorithm SEGMENT-INTERSECTION runs in time
O((n + m) log n).
We remark that the time complexity of the above algorithm depends on
the number m of intersection points of the segment and the algorithm is
not always ecient. For example, when the number m is of order
(n2 ),
then the algorithm runs in time O(n2 log n), which is even worse than the
straightforward method that picks every pair of segments and computes their
intersection point. On the other hand, if the number m is of order
(n),
then the algorithm runs eciently in time O(n log n).
4.2. CONSTRUCTING CONVEX HULLS 35
4.2 Constructing convex hulls
4.2.1 Jarvis's March
We start with a most straightforward method, Jarvis's March, which is also
known as gift wrapping method.
The idea is based on the observation we gave in the proof of Theo-
rem 3.1.3. Given a set S of n points in the plane, suppose we move a
straight line L sweeping the plane until L hits a point p1 of S . The point
p1 must be on the boundary of the convex hull CH(S) of S since at this
moment, all points of S are in one side of the line L and the point p1 is on
the line L. Now we rotate the line L around the point p1 , say counterclock-
wise, until L hits another point p2 of S . The segment p1 p2 is then on the
boundary of the convex hull CH(S) since again all points of S are in one side
of the line L and the segment p1p2 is on the line L. Now we rotate the line
L around p2 counterclockwise until L hits a third point p3 of S , then the
line segment p2p3 is the second boundary edge of CH(S), ........ Continue
this process until we come back to the rst point p1 . The convex hull CH(S)
then is constructed.
This process can also be regarded as a \wrapping" process. Suppose we
x an end of a rope on a point p1 that is known to be a hull vertex. Then
we try to \wind" the points by the rope (or \wrap" the points by the rope).
The rope obviously gives us the boundary of the convex hull when it comes
back to the point p1.
There are a few things we should mention in the above process. First of
all, the sweeping manner is special: the line L is rotated around a point in
the plane; secondly, the sweeping line status is very simple: it contains at
any moment a single point that is the hull vertex most recently discovered;
nally, the even points are the hull vertices.
Let us study the above process in detail. Suppose at some moment in the
middle of the process, the consecutive hull vertices which have been found
are p1, p2 , , pi . What point should be the next hull vertex? Obviously, the
point pi+1 rst touched by the rope should be it, when we rotate the rope
around the point pi . That is, the angle 6 pi?1 pi pi+1 should be the largest.
We implement this idea into the following algorithm.
Algorithm JARVIS'S MARCH
Given: a set S of n points in the plane

Output: the convex hull CH(S) of S
BEGIN
Let p(1) be the point in the set S that has the smallest
y-coordinate;
Let p(2) be the point in the set S such that the slope of
the line segment p(1)-p(2) is the smallest, with respect
to the x-axis;
PRINT(p(1), p(2));
i := 2 ;
WHILE p(i) <> p(1) DO
Let p(i+1) be the point in the set S such that the angle
<p(i-1)p(i)p(i+1) is the largest;
i := i + 1 ;
PRINT(p(i));
END.
Time complexity of Jarvis's March

Suppose there are k hull vertices in CH (S ). The points p1 and p2 are
obviously hull vertices. Moreover, it is also clear that to nd the points p1
and p2 takes time O(n), assuming S has n points. To nd each next hull
vertex pi+1 , we check the angle 6 pi?1 pi p for each point p in the set S . Thus
Step 4 spends time O(n) on each hull vertex. Therefore, Jarvis's March runs
in time O(kn).
If k is small compared with n, for instance, if k is bounded by a constant,
then Jarvis's March runs in linear time. However, if k is larger, such as
k =
(n), then the time complexity of Jarvis's March is
(n2).
4.2.2 Graham Scan

Look at Jarvis's algorithm. Each time based on the most recent hull vertex
p and the most recent hull edge e, we nd the next hull vertex by choosing
the point p0 which makes the angle between e and pp0 largest. To nd such
a point p0, we have to compute the angle between the segments e and pq for
all points q in the set S . For each hull vertex, we have to perform this kind
of computations. Therefore, in this process, even though we have found out
that a point p is not qualied for the next hull vertex, we still cannot exclude
the possibility that the point p is qualied for a later hull vertex. This is the
reason that we have to consider the point again and again. A point can be
considered up to n times in the worst case. A possible improvement is that
CONVEX HULLS 37
we presort the set of points in some way so that once we nd that a point is
not qualied for the next hull vertex, then we can exclude the point forever.
For example, let p0 , p1 and p2 be three distinct hull vertices of the convex
hull CH(S) for the set S . Suppose that the line segment p1 p2 is known to be
on the boundary of the convex hull CH(S). Then the line segments p0p for
all points p of S that are between the angle 6 p1p0 p2 should be entirely in the
triangle p0p1 p2 . Therefore, if we start with the point p1 , scan the points of
the set S , based on the point p0, counterclockwise, and keep a record for the
length of the line segment p0p for each point of S we have visited, then once
we reach the point p2, we can eliminate all points we have visited between
the points p1 and p2. This elimination is permanent, i.e., once a point is
eliminated, it will be ignored forever.
This idea is implemented by the following well-known algorithm, known
as Graham Scan algorithm.
Algorithm GRAHAM SCAN

Output: the convex hull CH(S) of S
{St is a stack}
BEGIN
1. Let p(0) be the point in S that has the smallest y-coordinate.
{ Without loss of generality, we can suppose that p(0) is the
origin, otherwise, we make a coordinate transformation }
2. Sort the points in the set S - p(0) by their polar angles.
Let the sorted list of the points be
L' = { p(1), p(2), ..., p(n-1) }
{in increasing polar angle ordering.}
3. Let
L = { p(1), p(2), ..., p(n-1), p(n) }
where p(n) = p(0);
q(1) = p(0); q(2) = p(1); PUSH(St, q(1));
PUSH(St, q(2)); i = 2; j = 2;
4. WHILE i <= n DO
IF q(j-1)q(j)p(i) is a left turn
THEN q(j+1) = p(i);
PUSH(St, q(j+1));
i++;
j++
ELSE POP(St);
j--;
END.
In Graham Scan, the sweeping line rotates around a xed point p0 . All
points in the set S are event points. Since the event points are presorted in
Step 2, it takes only constant time to nd the next event point in the sorted
list L. This makes Graham Scan very ecient.
Let us consider the time complexity of the algorithm in detail. Step 1 can
be done by comparing the y -coordinates of all points in the set S , thus it takes
time O(n); Step 2 can be done by any O(n log n) time sorting algorithm, for
example, MergeSort; Step 3 obviously takes constant time. To discuss the
time complexity of the loop in Step 4, observe that each point of the set
S can be pushed into the stack St and then popped out of the stack at
most once. Whenever a point is popped out from the stack, it will never
be considered any more. Therefore, there are at most 2n stack pushes and
pops. Now each execution of the loop in Step 4 either pushes a point into the
stack (Step 4.2) or pops a point out the stack (Step 4.3). Thus the loop is
executed at most 2n times. Since each execution of the loop obviously takes
constant time, we conclude that the total time taken by Step 4 is bounded
by O(n).
Therefore, the time complexity of Graham Scan is O(n log n).
We remark that most of the time in Graham Scan algorithm is spent on
Step 2's sorting. Besides sorting, Graham Scan runs in linear time.
The Step 2 in Graham Scan sorts the points in the given set S by their
polar angles. This involves in trigonometric operations. Although we have
assumed that our RAMs can perform trigonometric operations in constant
time, trigonometric operations can be very time consuming in a real com-
puter. We present a modied version of Graham Scan which avoids using
trigonometric operations.
The idea is as follows. Suppose we are given a set S of n points in the
plane. We add a new point p0 to the set S such that p0 's y -coordinate is
smaller than that of any point in the set S . Then we perform Graham Scan
on this new set. Draw a line segment p0p for each point p in the set S . It
can be easily seen that if the point p0 moves toward the negative direction
of the y -axis, these line segments are getting more and more parallel each
other. Imagining that eventually p0 reaches the innite point along the
negative direction of the y -axis, then all these line segments become vertical
FARTHEST PAIR 39
rays originating from the points of the set S . Now the ordering of the polar
angles of the points of S around p0 is identical with the ordering of the
x-coordinates of these points. (In fact, p0 does not have to be the innite
point, when p0 is far enough from the set S , the above statement should
be true.) Therefore, the convex hull of the new set can be constructed by
rst sorting the points in S by their x-coordinates instead of their polar
angles. It is also easy to see that the convex hull of the new set consists of
two vertical rays, originating from the two points pmin and pmax in the set
S with smallest and largest x-coordinates, respectively, and the part UH of
the convex hull of the original set S . This part UH of the convex hull CH(S)
is in fact the upper hull of CH(S) in the sense that all points of the set S lie
between the vertical lines x = xmin and x = xmax and below the part UH .
Similarly, the lower hull of the convex hull CH(S) can be constructed by the
idea of adding an innite point in the positive direction of the y -axis. The
convex hull CH(S) is simply the circular catenation of the upper hull and
the lower hull.
Now we give the formal algorithm as follows.
Algorithm MODIFIED GRAHAM SCAN

Output: the convex hull CH(S) of S;
BEGIN
Sort the points of the set S in decreasing x-coordinate
ordering;
Let pmax and pmin be the points of S that have the
largest and smallest x-coordinates, respectively.
Suppose pmax = (x, y), let p(0) = (x, y-1),
and p(1) = pmax;
Perform Graham Scan on the sorted list until the point
pmin is included as a hull vertex;
The ordered list of hull vertices found in this process
minus the point p(0) is the upper hull;
Construct the lower hull similarly;
Catenate the upper hull and lower hull to form the convex
hull CH(S).
END
The Modied Graham Scan obviously also takes time O(n log n).
4.3 The farthest pair problem
The problem we shall discuss in this section is formally dened as follows:
FARTHEST-PAIR
Find a pair of points in a given set which are farthest.
A brute force algorithm is to examine every pair of points to nd the
maximum distance thus determined. The brute force algorithm obviously
runs in time O(n2 ).
To get a more ecient algorithm, let us rst investigate what kind of
properties a farthest pair of points in a set has. Let us suppose that S is a
set of n points in the plane, and call a segment linking two farthest points
in the set S a diameter of the set S .
Lemma 4.3.1 Let uv be a diameter of the set S . Let lu and lv be two
straight lines that are perpendicular to the segment uv such that lu passes
through u and lv passes through v . Then all points of S are contained in the
slab between lu and lv .
proof. Without loss of generality, suppose that the segment uv is horizon-
tal and the point u is on the left of the point v . Draw a circle C centered at
u of radius juvj, then the line lv is tangent to C because lv is perpendicular
to uv. Thus the circle C is entirely on the left of the line lv . Since v is the
farthest point in the set S from the point u, all points of S are contained
in the circle C . Consequently, all points of S are on the left of the line lv .
Similarly, we can prove that all points of S are on the right of the line lu .
Therefore, all points of the set S are between the lines lu and lv .
Corollary 4.3.2 Let uv be a diameter of the set S , then the points u and
v are hull vertices of CH(S).
proof. As we discussed in Chapter 2, a point p in S is a hull vertex of
CH(S) if and only if there is a line passing through p such that all points of
S are on one side of the line.
Let u and v be two hull vertices of CH(S). The vertices u and v are called
an antipodal pair if we can draw two parallel supporting lines lu and lv of
CH(S) such that lu passes through u and lv passes through v , and the convex
hull CH(S) is entirely contained in the slab between the lines lu and lv .
FARTHEST PAIR 41
Corollary 4.3.3 Let uv be a diameter of the set S , then u and v are an
antipodal pair.
proof. By Corollary 4.3.2, u and v are hull vertices of CH(S). By
Lemma 4.3.1, we can draw two parallel lines lu and lv such that lu passes
through u, that lv passes through v , and that all points of S are contained
in the slab between lu and lv . The slab between lu and lv is clearly a convex
set. Since the convex hull CH(S) of S is the smallest convex set containing
all points of S , i.e., the convex hull CH(S) is contained in all convex sets
containing all points of S , so the convex hull CH(S) is contained in the slab
between the lines lu and lv .
According to Lemma 4.3.1 and its corollaries, to nd a farthest pair of
a set S of n points in the plane, we only need to nd a farthest pair of the
hull vertices of the convex hull CH(S). Moreover, we only need to consider
the antipodal pairs on the convex hull CH(S). This greatly simplies our
problem. We now consider the following problem: given a vertex u of a
convex polygon P , what vertices of P can constitute an antipodal pair with
the vertex u? To answer this question, we suppose that the vertices of the
convex polygon P are given in counterclockwise ordering: fu1 ; u2; ; um g.
For simplicity, we say that a vertex ui of P is the farthest from an edge
uk?1 uk of P if ui is the farthest vertex in P from the straight line on which
uk?1 uk lies.
Lemma 4.3.4 Let uk?1uk be an edge of P . We scan the vertices of P
in counterclockwise order, starting with the vertex uk . Let ui be the rst
farthest vertex from the edge uk?1 uk . Then no vertex between uk and ui can
constitute an antipodal pair with uk .
proof. Without loss of generality, suppose that the edge uk?1 uk is hori-
zontal and the vertex uk is on the right of the vertex uk?1 . First note that
for any vertex ui of P , the angle between the edge ui ui+1 and the x-axis
is between 0 and 2 . Let be the angle between the edge uk uk+1 and the
x-axis. Suppose that 1 (2 ) is the angle between the edge ui?1 ui (uiui+1 )
and the x-axis. Since P is convex, 1 2 . See Figure 4.1 for illustration.
It is easy to see that the vertex ui constitutes an antipodal pair with the
vertex uk if and only if the angle region [1 ; 2] contains an angle between
and + . Let uj be a vertex between uk and ui , (uj 6= uk ; ui). Then uj is
not farthest from the edge uk?1 uk . Thus the angle between the edge uj uj +1
α2
ui
α1
ui + 1
ui-1
u k+1
α
uk-1 uk
Figure 4.1: The convex polygon P
and the x-axis, and the angle between the edge uj ?1 uj and the x-axis are all
strictly less than . That is, the vertex uj does not constitute an antipodal
pair with uk .
Lemma 4.3.5 Let uk?1uk be an edge of P . We scan the vertices of P in
counterclockwise order, starting with the vertex uk . Let ur be the last far-
thest vertex from the edge uk?1 uk . Then no vertex between ur and uk?1 (in
counterclockwise ordering on the boundary of P ) can constitute an antipodal
pair with uk?1 .
proof. Completely similar to the proof of Lemma 4.3.4.
Now it is clear how we nd all antipodal pairs on the convex polygon P :
starting with an edge uk?1 uk , we scan the vertices of P counterclockwise until
we hit the rst farthest vertex ui from the edge uk?1 uk . By Lemma 4.3.4,
ui is the rst vertex of P that constitutes an antipodal pair with the vertex
uk . Now we continue scanning the vertices until we hit a vertex ur that
is the last farthest vertex to the edge uk uk+1 . By Lemma 4.3.5, ur is the
last vertex that constitutes an antipodal pair with the vertex uk . Now a
vertex constitutes an antipodal pair with uk if and only if it is between ui
and ur . Moreover, since we suppose that no three vertices of P are co-linear,
there are at most two farthest vertices from an edge on P . The algorithm of
nding all antipodal pairs of a convex polygon P is given in detail as follows.
FARTHEST PAIR 43
Algorithm ANTIPODAL-PAIRS
Given: a convex polygon P = { u(1), ...., u(m) } in

counterclockwise ordering
Output: all antipodal pairs of P
BEGIN
1. Starting with the edge {u(0), u(1)}, where we let
u(0) be the vertex u(m). Set k = 1 and i = 2.
2. WHILE u(i) is not a farthest vertex from the edge
{u(k-1), u(k)}
i = i + 1;
3. { At this point u(i) is a farthest vertex from the
edge {u(k-1), u(k)}. }
WHILE u(i) is not a farthest vertex from the edge
{u(k), u(k+1)}
OUTPUT [u(k), u(i)] as an antipodal pair;
i = i + 1;
4. { At this point u(i) is the first farthest vertex
from the edge {u(k), u(k+1)}. We check if u(i)
is the last farthest vertex from the edge
{u(k), u(k+1)}. }
IF u(i+1) is also a farthest vertex from the edge
{u(k), u(k+1)}
OUTPUT [u(k), u(i)], [u(k+1), u(i)] as
antipodal pairs;
i = i + 1;
5. { Now u(i) must be the last vertex that can consti-
tute an antipodal pair with u(k). }
OUTPUT [u(k), u(i)] as an antipodal pair;
6. IF k < m, THEN
k = k + 1;
GOTO Step 3;
END.
The addition i = i + 1 in the algorithm should be \(mod m)", that is,

if i = m, then i + 1 = 1. Note that the distance from a vertex ui to the
line on which the edge uk?1 uk lies is proportional to the area of the triangle
4(uiuk?1 uk ), therefore the vertex ui is the farthest from the edge uk?1 uk if
and only if the area of the triangle 4(uiuk?1 uk ) is less than neither the area
of the triangle 4(ui?1uk?1 uk ) nor the area of the triangle 4(ui+1uk?1 uk ).
An intuitive description of the above algorithm is that we use two parallel
lines to sandwich the convex polygon P , then rotate the lines along the
boundary of P , keeping the lines in parallel. We report all pairs of vertices
of P that are at some moment on the two parallel lines at the same time,
respectively, when we rotate the lines.
The analysis of the algorithm is straightforward. We keep two pointers k
and i. In constant time, at least one pointer is advanced. Since the pointer
k is from 1 to m and the pointer i marches the convex polygon P at most
twice (the pointer i stops at the last farthest vertex from the edge um u1 ),
we conclude that the time complexity of the algorithm is bounded by O(m).
A further improvement can be made in the above algorithm if we observe
that when the pointer i reaches the vertex um , then all antipodal pairs have
actually been found. In fact, if the pointer i is advanced from the vertex
um to the vertex u1, then we are considering the vertex u1 as a candidate
that constitutes an antipodal pair with some other vertex of P . However,
all vertices that constitute antipodal pairs with u1 have been found when
the pointer k is advanced from the vertex u1 to the vertex u2 . Since this
improvement does not change the asymptotical order of the time complexity
of the algorithm, we will not discuss it in detail.
Now we give the algorithm for the FARTHEST-PAIR problem.
Algorithm FARTHEST-PAIR

Output: the farthest pair
BEGIN
1. Construct the convex hull CH(S) of S;
2. Call ANTIPODAL-PAIRS on CH(S);
3. Scan the result of Step 2 and select the pair
with the longest distance.
END.
By the discussions given in this section, the above algorithm nds the
farthest pair for a given set S correctly. Moreover, the algorithm runs in
time O(n log n) since it is dominated by the rst step.
4.4. TRIANGULATIONS 45
4.4 Triangulations
TRIANGULATING a set S of n points in the plane is to joint the points
in the set S by non-intersecting straight line segments so that every region
interior to the convex hull of S is a triangle. In this section we shall discuss a
more general version of TRIANGULATION: given a set S of n points in the
plane and a set E of non-intersecting straight line segments whose endpoints
are the points in S , construct a triangulation T (S ) of S such that all the
segments in the set E appear in the triangulation T (S ).
Recall that a planar straight line graph (PSLG) G = (S; E ) is a nite
set S of points in the plane plus a set E of non-intersecting straight line
segments whose endpoints are the points in the set S . We always suppose
that a PSLG G is represented by a doubly-connected edge list (DCEL).
The problem we shall discuss is called Constrained Triangulation.
CONSTRAINED TRIANGULATION
Given a PSLG G = (S; E ), construct a triangulation T (S ) of S such that
all segments of E are edges of T (S ).
4.4.1 Triangulating a monotone polygon

We rst discuss the problem for a special class of PSLG's, called monotone
polygon.
A chain C = (v1; v2; ; vr ) is a PSLG with a point set S =
fv1; v2; ; vr g and a segment set E = f(vi; vi+1) j 1 i n ? 1g. A
chain C is monotone with respect to a straight line l if any straight line
orthogonal to l intersects the chain C at at most one point.
Denition A polygon P is said to be monotone with respect to a straight
line l if P is a simple polygon and the boundary of P can be decomposed
into two chains monotone with respect to the straight line l.
If a polygon P is monotone with respect to the y -axis, we simply say
that the polygon P is monotone.
We rst solve the following problem: given a monotone polygon P , tri-
angulate the interior of P . That is, we add edges to the polygon P so that
each region in the interior of P is a triangle.
A vertex u of a polygon P is visible from a vertex v if we can draw
a straight line segment s connecting u and v such that the interior of the
segment s is entirely in the interior of the polygon P . In particular, a vertex
is not visible from any of its adjacent neighbors. Moreover, note that a
vertex v is visible from a vertex u if and only if the vertex u is visible from
the vertex v .
The method we are going to use is a \greedy" method. Standing at each
vertex v of the polygon P , we look through the interior of the polygon P
and see which vertex of the polygon P is visible. Whenever we nd that
a vertex u of the polygon P is visible from the vertex v , we add an edge
between the vertices v and u. Keeping doing this until no vertex of P is
visible from the vertex v , then we move to another vertex v 0 of P and add
edges to those vertices that are visible from v 0 , an so on. Note that once
there is no vertex visible from a vertex v of P , then no vertex can become
a visible vertex from v later, since the only operation we are performing is
adding edges to the interior of the polygon P . Therefore, once we add edges
to a vertex v of P so that there is no vertex of P visible from v , we do not
have to come back and check the vertex v again. Moreover, if the interior
of the polygon P is not triangulated, then there must be a pair of vertices v
and u between which we can add a new edge e without edge-crossing. But
this implies that the vertex u is still visible from the vertex v before we add
the new edge e. Thus, if we process all vertices of P such that from any
vertex v of P there is no visible vertex, then we must have triangulated the
interior of the polygon P .
The above method is principally valid for triangulating any PSLG. How-
ever, to nd all visible vertices from a vertex of a general PSLG may be
time-consuming. On the other hand, if the PSLG is a monotone polygon,
then the process above can be done very eciently.
The following is the algorithm of triangulating a monotone polygon P .
We process the vertices, in the way described above, in the ordering of
decreasing y -coordinate. A stack STACK is used to store those vertices of
P that have been processed such that no processed vertices are still visible
from a vertex in the STACK and each vertex in the STACK is still visible
from some unprocessed vertices of P .
Algorithm TRIANGULATING-MONOTONE-POLYGON
Given: a monotone polygon P

Output: a triangulation of P
TRIANGULATIONS 47
BEGIN
1. Sort the vertices of P in decreasing y-coordinate,
Let the sorted list be
L = { v(1), v(2), ...., v(n) }
2. Push the vertices v(1) and v(2) into the stack
STACK. Let i = 3.
3. Suppose that the vertices in the STACK are
STACK = { u(1), u(2), ...., u(s) }
where u(s) is the top and u(1) is the bottom.
4. IF v(i) is adjacent to u(1) but not to u(s)
{ we will prove later that in this case, stack
vertices u(2), u(3), ...., u(s) are all visible
from v(i). } THEN
add edges {v(i), u(2)}, {v(i), u(3)}, ....,
{v(i), u(s)}, pop all STACK vertices, then
push u(s) and v(i) into the STACK;
i++;
GOTO Step 7;
5. IF v(i) is adjacent to u(s) but not to u(1)
{ in this case, u(s) is not visible from v(i), we
check if any other STACK vertices are visible
from v(i). } THEN
WHILE the second top vertex of the STACK
(call it u') is visible from v(i) DO
add an edge {v(i), u'};
pop the top vertex from STACK;
PUSH v(i) into STACK;
i++;
GOTO Step 7;
6. IF v(i) is adjacent to both u(s) and u(1)
{ in this case, v(i) is the last vertex in the
list L, and all STACK vertices except u(s) and
u(1) are visible from v(i). } THEN
add edges {v(i), u(2)}, {v(i), u(3)}, ......,
{v(i), u(s-1)};
POP all STACK vertices and STOP.
7. IF i <= n, go back to Step 3.
END.
We rst discuss the correctness of the algorithm. Each execution of the

loop Step 3 - Step 6 results in a PSLG. Let the PSLG after processing the
vertex vi be Gi . (So G0 = P and Gn should be a triangulation of P .)
We prove that the following properties are always maintained for all Gi 's.
Suppose the STACK content is fu1; u2; ; us g.
Properties of Gi
1. The STACK contains at least two vertices for G0 , G1 , , Gn?1 .
2. The STACK vertices fu1 ; ; usg is a monotone chain on the boundary
of some region Pi of Gi that is a monotone polygon.
3. The processed vertices that are not in the STACK are not visible from
any vertex of Gi .
4. No STACK vertex is visible from any other STACK vertex in Gi .
If for each Gi , the above properties are maintained, then since for Gn ,
all vertices of P are processed and the STACK is empty, by Property 3, no
vertex of Gn is visible from any other vertex of Gn . As we discussed earlier
in this section, the PSLG Gn must be a triangulation.
We prove by induction that the above four properties are always main-
tained by every PSLG Gi . For G0, the properties are trivially maintained
because of Step 1 and Step 2. Now suppose that the properties are also
maintained for the PSLG Gi?1 . To obtain Gi , we execute Step 3 - Step 6
based on Gi?1 .
Property 1 is obviously maintained, since if i < n then either Step 4
or Step 5 is executed. But both of them leave at least two vertices in the
STACK.
To maintain Property 2, note that by inductive hypothesis, all processed
vertices that are not in STACK for Gi?1 are not visible from any vertex
of Gi?1 , that is, all the regions incident to those vertices must be triangles.
Thus the edges to be added in Step 4 or Step 5 must be within the monotone
polygon Pi . Moreover, the vertex vi is the only new vertex added to the
STACK and the y -coordinate of vi is less than that of any STACK vertex.
Finally, the vertex vi is always connected to the top vertex in STACK before
vi is pushed into STACK. These observations make sure that Property 2 is
also maintained for Gi .
Now let us consider Property 3. For those processed vertices that are not
in STACK for Gi?1 , they are not visible from any vertices of Gi?1 , thus they
are also not visible from any vertices of Gi since Gi is obtained by adding
edges to Gi?1 . Suppose that ur is a vertex that is in the STACK for Gi?1
but popped out by Step 4, by Step 5, or by Step 6.
TRIANGULATIONS 49
If ur is popped by Step 4, then r < s. The vertex ur is visible from
neither a vertex in STACK nor a processed vertex that is not in STACK, by
the inductive hypothesis. Moreover, the edge vi ur+1 blocks ur from being
visible from any unprocessed vertex. The same proof applies to the case that
ur is popped by Step 6.
If ur is popped by Step 5, then at some moment in the \While" loop of
Step 5, ur is the top vertex of STACK. Let u0 be the second top vertex of
the STACK. The vertex ur is popped because the edge vi u0 is added. Since
vi has a smaller y-coordinate than ur , the edge vi u0 blocks ur from being
visible from any unprocessed vertex.
Therefore, if ur is popped from the STACK for Gi?1 when we are con-
structing Gi, then ur is no longer visible from any vertex of Gi .
Finally, consider Property 4. If Step 4 is executed, the STACK contains
two adjacent vertices us and vi , so Property 4 is obviously maintained. If
Step 5 is executed, then we add an edge between the second top vertex u0
of STACK and vi when u0 is visible from vi . We keep doing this until the
second top vertex u0 of STACK is no longer visible from vi . At this point, no
other STACK vertex could be visible from vi since otherwise, let u00 be the
rst vertex in STACK that is visible from vi , then it is easy to see that u00
should also be visible from the rst top vertex of STACK, contradicting our
inductive hypothesis. This proves that Property 4 can always be maintained.
By the above discussion, it can also be realized that if Step 4 is the case,
then all STACK vertices u2 , u3 , , us are visible from the vertex vi . In
fact, if u2 is not visible from vi , then the edge vi u2 must intersects some
edge of Gi?1 . Since vertices vi , u1 , u2 , , us are consecutive vertices on the
boundary of Pi?1 (remember that in this case we suppose that vi is adjacent
to u1 ), if vi u2 intersects some edges of Gi?1 , then vi u2 must also intersect
the chain C = fu1 ; u2; ; usg on the boundary of Pi?1 . But this implies
that some vertex on the chain C is visible from the vertex u1, contradicting
our inductive hypothesis. Similarly, we can prove that after adding edges
viu2 , vi u3 , , vi ur?1 , the vertex ur is still visible from the vertex vi, for
r = 3; ; s.
This completes the discussion of the correctness of the algorithm.
The analysis of the algorithm is easier. Since the polygon P is monotone,
there are two vertices v0 and vr of P with the largest and the smallest y -
coordinates, respectively. Moreover, the boundary of the polygon P can be
decomposed into two monotone chains
C = (u0; u1; ; uk) and C 0 = (u00; u01; ; u0h)
where u0 = u00 = v0 and uk = u0h = vr and the vertices in both chains C and
C 0 are in decreasing y-coordinate ordering. We can merge the two chains C
and C 0 in linear time to obtain the list L of vertices of the polygon P sorted
by decreasing y -coordinate. Therefore, Step 1 of the algorithm takes linear
time.
Within the loop of Step 4 - Step 7, we add each new edge in constant
time. Since the nal triangulation Gn is a planar graph that has at most
O(n) edges, so the total time for adding new edges is bounded by O(n).
Finally, since each vertex of P is pushed into then popped out the stack
STACK exactly once, the total time is again bounded by O(n).
We close this subsection with the conclusion that the problem of trian-
gulating a monotone polygon can be solved in linear time.
4.4.2 Triangulating a general PSLG
Now we consider the problem of triangulating a general PSLG. Given a
general PSLG G of n points, let
F = fP1; P2; ; Pr g
be the set of regions of G. If each region of G is a monotone polygon, we
can use the following method to triangulate G: use the TRACE-REGION
algorithm in Section 1.4 to nd all regions
P1 ; P2; ; Pr
Let #Pi be the number of edges of the polygon Pi , which is also the number
of vertices of Pi . Then the region Pi can be constructed in time O(#Pi ).
Therefore, to nd all regions of G takes time
O(#P1) + O(#P2) + + O(#Pr ) = O(#P1 + #P2 + + #Pr )
Since each edge of G is used by exactly two regions of G in their bound-
ary, (#P1 + #P2 + + #Pr ) is twice the number of edges of G, which
is bounded by O(n) since G is a planar graph. That is, the regions of G
can be constructed in linear time. Now we triangulate each region Pi of G
using the algorithm TRIANGULATING-MONOTONE-POLYGON given in
the last subsection. The time for triangulating the monotone polygon Pi is
bounded by O(#Pi ). Therefore, triangulating all regions of G takes linear
time. It is easy to see that putting all these triangulated regions together to
get a triangulation of G can also be done in linear time. We conclude that
TRIANGULATIONS 51
if all regions of a PSLG G are monotone polygons then the triangulation of
G can be done in linear time.
Therefore, the problem of triangulating a general PSLG G is reduced to
the problem of converting the PSLG G into a PSLG G0 such that all regions
of G0 are monotone polygons. Without loss of generality, we suppose that
our PSLG G has no two points with the same y -coordinate (otherwise we
can achieve this by rotating the coordinate system slightly). Let us rst
introduce some denitions.
Let G be a PSLG and let v be a point of G. An edge fu; v g is an upper
edge of v if the y -coordinate of u is larger than that of v , and an edge fw; v g
is a lower edge of v if the y -coordinate of w is smaller than that of v . A vertex
v of G is regular if either v is the vertex of G with maximum or minimum
y-coordinate or v has both upper edges and lower edges.
Denition Let G be a PSLG. G is a regular PSLG if every vertex of G is
a regular vertex.
Note that if G is a regular PSLG, then G must be connected. In fact,
suppose that G is not connected, let v0 and v00 be the vertices of maximum
y-coordinate of two dierent connected components of G, respectively. Then
both v0 and v00 have no upper edges, so one of them must be an unregular
vertex of G.
Lemma 4.4.1 If G is a regular PSLG, then all regions of G are monotone
polygons.
proof. Suppose that G is a regular PSLG but a region P of G is not
a monotone polygon. Let v0 be the vertex of P that has the largest y -
coordinate. Since P is a simple polygon and no vertex of P has the same
y-coordinate as v0, when a horizontal straight line l is close enough to the
vertex v0 , l intersects P at exactly two points. Because P is not monotone,
there must be some horizontal lines intersecting P at more than two points.
Let
r0 = supfr j the line y = r intersects P at more than two points.g
Let l0 be the horizontal straight line y = r0 . There are two possible cases.
The line l0 intersects P at two points. Then since a slight moving down
of the line l0 would make the line intersect more than two points, there must
be a vertex v of P on the line l0 such that the vertex v has two lower edges.
Since l0 intersects P at two points, v is not v0 . However, v has no upper
edges since each vertex of P is incident to exactly two edges of P , so v is
not a regular vertex and G is not a regular PSLG.
On the other hand, suppose that l0 intersects P at more than two points,
then a slight moving up of the line l0 would make the line intersect exactly
two points. Thus one of those intersecting points of l0 and P must be a
vertex of P without upper edges. But this again contradicts the assumption
that G is regular.
Therefore, the region P must be a monotone polygon.
Therefore, the TRIANGULATION problem for regular PSLGs can be
done in linear time. In the next subsection, we will show that given
a general PSLG G, in time O(n log n) we can convert G into a regular
PSLG by adding edges to G. Consequently, the problem CONSTRAINED-
TRIANGULATION can be solved in time O(n log n).
Remark:
Chazelle [8] has recently proven that triangulating a simple polygon (not
necessarily a monotone polygon) can be done in linear time. Since for a
connected PSLG G, the regions of G can be constructed in linear time, and
each region is a simple polygon, we use Chazelle's linear time algorithm to
triangulate each region of G then put them together. This gives us a linear
time algorithm for triangulating a connected PSLG.
4.4.3 Regularization of PSLGs

We thereby have the following problem.
REGULARIZATION-PSLG
Given a general PSLG G, add edges to G so that the resulting PSLG is
regular.
Intuitively, to regularize a PSLG, we add an upper edge to a vertex if
it does not have an upper edge, and add a lower edge to a vertex if it does
not have a lower edge. The problem is, how do we add the edges so that
edge-crossing is avoided. Therefore, when we are working on a vertex of a
PSLG G, we should have enough information about the local environment
of the vertex. But how do we maintain and update the information about
TRIANGULATIONS 53
the local environment eciently when we move from one vertex to another
vertex?
Again, the plane sweeping technique helps. Let V = fv1 ; v2; ; vng be
the vertex set of a PSLG G. Without loss of generality, suppose that no two
vertices in V have the same y -coordinate.1 We rst sort the vertices in V
by their y -coordinate. Then we sweep the plane by a horizontal line from
bottom up. The sweeping stops at each vertex of G and check if the vertex
has an upper edge. If the vertex does not have an upper edge we add one
for it. Then we sweep the plane once again from top down to add lower
edges for those vertices without lower edges. After these two sweepings,
every vertex has at least one upper edge (except for the vertex with the
maximum y -coordinate) and at least one lower edge (except for the vertex
with the minimum y -coordinate). Thus the PSLG becomes regular. We
discuss the bottom-up sweeping in detail. The top-down sweeping can be
handled similarly.
Without loss of generality, suppose that the list fv1; v2; ; vng is the
sorted list of vertices of the PSLG G in ascending y -coordinate. Consider
the sweeping line l at vertex vi , where i < n. The sweeping line l partitions
the PSLG G into three parts G1, G2 and G3. G1 is the \past history"
containing those vertices of G that are below the line l and have at least
one upper edge each, and those edges of G that are entirely below the line
l. G2 is the \current status" containing the vertices of G that are either
on the line l or below the line l and have no upper edges, and those edges
of G that intersect the line l. G3 is the \unknown future" containing the
vertices and edges of G that are entirely above the line l. The elements in
G1 are \nice" elements that we have seen and we know that they do not
make trouble for us. The elements in G2 are \current" elements that we
should process. The elements in G3 are unknown elements to us since we
have not seen them during the bottom-up sweeping. Therefore, the process
of the plane sweeping is a process of updating the current status G2 when
we pass through a vertex v of the PSLG G. This is easy to see that during
the sweeping between two consecutive vertices in the list fv1; v2; ; vn g, the
current status G2 is invariant. The current status G2 only changes when we
pass through a vertex of the PSLG G. This is the reason why our sweeping
is discrete (i.e., the sweeping only stops at the vertices of G and updates the
current status).
We require that between two intersecting edges of G in G2 that are
1 In fact, with a minor modication, our algorithms will also work for the general case.
consecutive on the line l, there is at most one \hanged vertex", i.e., a vertex
that is below the line l and has no upper edges. This condition can be easily
maintained since when a second hanged vertex is added between the edges,
we can connect it to the rst hanged vertex by a new edge thus give the rst
hanged vertex an upper edge and unhang it.
The current status G2 can be maintained in the following way when we
are passing through a vertex vi : we rst search the nearest left edge e1 and
the nearest right edge and er of vi in G2. Let e2 , , er?1 be the lower
edges incident on vi in counterclockwise ordering. We then check if there is
a hanged vertex vh between a pair (ej ; ej +1) of edges, for j = 1; ; r ? 1.
If there is one then we add a new edge between vi and vh and unhang the
vertex vh . Then we delete the lower edges of vi from G2 and add the upper
edges of vi to G2 . If vi has no upper edges, then we hang vi between the
two nearest edges e1 and er in G2 . Sweeping all vertices from v1 to vn and
updating G2 and G dynamically, we will nally nish adding upper edges to
the vertices of G. It is easy to see that after this process, each vertex of G,
except vn , has at least one upper edge.
Therefore, the following operations should be done eciently on G2 by
our algorithm: nding the edges e1, e2 , , er in G2 such that e1 and er are
the nearest left and the nearest right edges of the vertex vi in G2 , respectively,
and e2 , , er?1 are the lower edges incident on vi ; deleting an edge from
G2 ; and adding an edge to G2 .
Note that if we lower the sweeping line l a little bit, the intersecting points
of the line l and the edges e1 , e2 , , er are consecutive on l. Therefore, if
we put the edges in G2 in a list in the ordering of their intersections with
the line l, then the edges e1 , e2 , , er correspond to a consecutive sublist
of the list.
A proper data structure for eciently implementing the above operations
is a 2-3 tree T . The edges in G2 are ordered from left to right according to
the ordering of their intersections with the line l. Hanged vertices in G2 are
hanged between consecutive leaves in the tree T .
The following algorithm is based on the above discussion.
Algorithm ADD-UPPER-EDGES
Given: a PSLG G of n vertices, represented by a DCEL

Output: a PSLG G', obtained by adding edges to G such
that each vertex of G' (except the highest
one) has at least one upper edge.
TRIANGULATIONS 55
BEGIN
1. Sort the vertices of G in increasing y-coordinates,
let { v(1), ...., v(n) } be the sorted vertex list;
2. Create an empty 2-3 tree T; insert the upper edges
of v(1) into T if they exist , otherwise hang v(1);
3. FOR i = 2 up to n DO
3a. Using the x-coordinate of the vertex v(i) to
find two edges e(1) and e(r) in T that are the
nearest left and the nearest right edges of
v(i) in T. All the edges e(2), ...., e(r-1)
that are between e(1) and e(r) in the tree T
are lower edges of v(i).
3b. For j = 1 to r-1
IF there is a hanged vertex v(h) between
e(j) and e(j+1) THEN
add a new edge {v(h), v(i)};
unhang v(h);
3c. Delete the lower edges e(2), ...., e(r-1) of
v(i) from T if they exist;
3d. IF v(i) has upper edges THEN
insert the upper edges of v(i) into T
ELSE
hang v(i) between the nearest left and
right edges e(1) and e(r) if i <> n.
END.
We give the analysis of the algorithm. Step 1 can be done in time (n log n)
by any optimal sorting algorithm. Since each leaf of T corresponds to an edge
in G and G is a planar graph, T contains at most O(n) leaves. Consequently,
the depth of the tree T is at most O(log n). Thus Step 3a can be done in
time O(log n) for each vertex of G. Each vertex of G can be hanged and
unhanged at most once so the total time used to hang and unhang vertices
of G is bounded by O(n). Finally, each edge of G is inserted exactly once
(at its lower endpoint) then deleted exactly once (at its upper endpoint) in
the tree T , thus the time spent on inserting and deleting a single edge of
G is bounded by O(log n). Summarizing all these discussions, we conclude
that the algorithm ADD-UPPER-EDGES has time complexity O(n log n).
Chapter 5
Divide and Conquer

Divide and Conquer is a classical problem solving technique and has proven
its value for geometric problems as well. This technique normally involves
partitioning of the original problem into several subproblems, recursively
solving each subproblem, and then combining the solutions to the subprob-
lems to obtain the solution to the original problem. A general form of a
divide and conquer algorithm is as follows:
Algorithm DIVIDE AND CONQUER
Given: A problem P of size n

Output: A solution to P
BEGIN
0. IF n = 1 THEN
Solve the problem P directly and STOP;
1. Divide the problem P into k subproblems of size n/k;
2. Recursively solve each subproblem;
3. Combine the solutions to the subproblems to obtain
a solution to the problem P;
END.
The \size" of the problem P is a reasonable measure of the quantity of

input data. For example, if the problem is to construct the convex hull of a
set S of points in the plane, then the size of the problem can be the number
of points in the given set S .
57
58 DIVIDE AND CONQUER
To make the algorithm ecient, we in general expect that Step 1 of
dividing into subproblems and Step 3 of combining subsolutions can be done
in linear time.
Now we analyze the algorithm. Suppose that the time complexity of the
algorithm is T (n) on problems of size n. We assume reasonably that when the
problem has size 1, the problem can be solved in constant time, i.e., T (1) = b,
where b is a constant. By our assumption, Step 1 and Step 3 can be done in
time cn, where c is again a constant. Recursively, each subproblem of size
n=k can be solved in time T (n=k). So to solve all subproblems, Step 2 takes
time kT (n=k). Therefore, the time complexity of the algorithm DIVIDE
AND CONQUER can be expressed by the following recurrence
T (1) = b
T (n) = kT (n=k) + cn
It is an easy exercise to obtain the closed form for the function T (n), as
stated by the following theorem.
Theorem 5.0.2 If Step 1 and Step 2 can be done in linear time, then the
algorithm DIVIDE AND CONQUER runs in time
T (n) = O(n log n)
5.1 Convex hulls again

In this section, we present two divide and conquer algorithms for construct-
ing convex hulls for sets of points in the plane, MERGEHULL and QUICK-
HULL, which are the analogues of the famous sorting algorithms MERGE-
SORT and QUICKSORT, respectively.
The idea of MERGEHULL is exactly like that of MERGESORT. Given
a set S of n points in the plane, we rst split S into two subsets S1 and S2
of roughly equal size, then we separately construct the convex hulls CH(S1)
and CH(S2) for each of the sets S1 and S2. Finally, we merge the two hulls
into a larger hull for the original set S .
Some details are worth to discuss. To make our merge process easier,
we would like to let the two hulls CH(S1) and CH(S2) disjoint. This can be
done by letting the subset S1 be the half of S with smaller x-coordinates,
while letting the subset S2 be the half with larger x-coordinates. There are
CONVEX HULLS 59
two dierent ways to split the set into such two sets. One is to use a linear
time algorithm, developed by Blum, Floyd, Pratt, Rivest, and Tarjan [5], to
nd the point p with the median x-coordinate, then spit S into S1 and S2
according to p. Another way is to presort the set S by x-coordinates, then
for a sorted list, the median can always be found in linear time. We will
adopt the second approach.
The following is the detailed MERGEHULL algorithm.
Algorithm MERGEHULL

Output: the convex hull of S
BEGIN
1. Sort S by x-coordinates;
2. Call MHULL(S)
END.
The subroutine MHULL(S) is as follows.
Algorithm MHULL(S)
Given: a set S of n points in the plane, sorted by

x-coordinate
BEGIN
1. IF S contains less than four points, construct the
convex hull CH(S) directly. Otherwise, do the
following.
2. Split S into two subsets S_1 and S_2 of roughly
equal size, such that the x-coordinate of any point
in S_1 is less than the x-coordinate of any point
in S_2;
3. Recursively call MHULL(S_1) and MHULL(S_2) to
construct the convex hulls CH(S_1) and CH(S_2);
4. MERGE(CH(S_1), CH(S_2)) to obtain CH(S).
END.
All that is left to specify is how to perform the subroutine
MERGE(CH(S1), CH(S2)). For this, we must nd two lines: one that is
tangent to the top of both CH (S1) and CH (S2) (the upper bridge) and one
that is tangent to the bottom of both hulls (the lower bridge). Let u(S1 )
and l(S1) be the vertices in set S1 that are on the upper and lower bridges,
respectively (similarly dene u(S2) and l(S2)). Then all vertices in CH (S1)
proceeding clockwise from u(S1) to l(S1) can be discarded. Similarly, all
vertices in CH (S2) proceeding counterclockwise from u(S2) to l(S2) can be
discarded. All the remaining vertices form the convex hull CH (S ).
Now we nd the upper bridge (lower bridge is a symmetric operation).
Let us assume that the convex hulls of CH (S1) and CH (S2) are each stored
as a doubly-linked list. In constant time, we can add a point , delete a point,
or nd the clockwise or counterclockwise neighbor of a point. Suppose we
had a guess for the endpoints of the upper bridge. How can we verify the
guess? Suppose we guess that some line l through p 2 CH (S1) is tangent
to the hull CH (S1) at point p. Let p0 and p00 be the two neighbors of the
point p in the hull CH (S1). The line l is tangent to the top of CH (S1) at
the point p if and only if both points p0 and p00 are on or below the line l.
Therefore, to construct the upper bridge, we can pick any hull vertex
p from CH (S1) and any hull vertex q from CH (S2) and let l be the line
through p and q . Now we try to \lift" the line l as much as possible with the
condition that l intersects both hulls CH (S1) and CH (S2). Once we cannot
lift the line l anymore, the line l must be tangent to the top of both CH (S1)
and CH (S2), i.e., l is the upper bridge of CH (S1) and CH (S2). Note that if
the two neighbors p0 and p00 of the point p are on the two sides of the line l,
we can always use \signed triangle area" to decide which neighbor is above
the line l.
We give the detailed algorithm as follows.
Algorithm UpperBridge(CH(S_1), CH(S_2))
Given: two convex hulls CH(S_1) and CH(S_2) that

are separated by a vertical line such that
CH(S_1) is on the left of the line
Output: the upper bridge of CH(S_1) and CH(S_2)
BEGIN
1. Let p be the point in CH(S_1) with the smallest
x-coordinate, and let q be the point in CH(S_2)
CONVEX HULLS 61
with the largest x-coordinate. Let L be the
line through p and q;
2. WHILE L is not the upper bridge DO
2.1. WHILE there is a neighbor p' of p in CH(S_1)
above the line L, replace the point p by the
point p' and construct the new line L;
2.2. WHILE there is a neighbor q' of q in CH(S_2)
above the line L, replace the point q by the
point q' and construct the new line L;
END.
The lower bridge of CH (S1) and CH (S2) can be found by an algorithm

which is identical with the algorithm UpperBridge except that the word
\above" is replaced by the word \below".
In the worst case, the line l in the algorithm UpperBridge passes through
every hull vertices of CH (S1) and every hull vertices of CH (S2). Then the
algorithm must stop. Therefore, the running time of the algorithm Upper-
Bridge is at most linear to the number of hull vertices of the two hulls, which
is bounded by the number of points in the set S1 [ S2 . To merge two hulls
which are separated by a vertical line, it suces to nd the upper and lower
bridges, delete a partial hull from each of the hulls, and catenate the remain-
ing parts of the hulls with the upper and lower bridges properly. All these
can be obviously done in time O(n) if the set S1 [ S2 contains n points and
the convex hulls are stored as doubly-linked lists. We conclude that the time
complexity of the subroutine MERGE is O(n).
Now we analyze the time complexity of the algorithm MERGEHULL. If
an O(n log n) time sorting algorithm is used, then the time of the algorithm
MERGEHULL equals O(n log n) plus the time of the algorithm MHULL.
Since the set S is presorted by x-coordinates, Step 2 of the algorithm
MHULL(S), i.e., splitting S into S1 and S2 can be done in time O(n). By
the analysis above, Step 4 of the algorithm can also be done in time O(n).
Moreover, since the set S is presorted by x-coordinates, when we pass the
sets S1 and S2 to the recursive calls MHULL(S1) and MHULL(S2), the sets
S1 and S2 are also presorted by x-coordinates. Thus the subroutine MHULL
directly applies. Now by the discussion at the beginning of this chapter, we
conclude that the time complexity of the algorithm MHULL is O(n log n).
As in MERGESORT, MERGEHULL splits the given input S carefully
(into two equal size subsets), then merges carefully the two hulls which are
obtained by recursive calls. The algorithm is in some sense very \stable".
That is, the time complexity is almost invariant for all inputs. On the other
hand, QUICKSORT randomly splits the given list of numbers, recursively
calls the subroutine, then simply catenates the two sorted sublists. There-
fore, much less work is done besides the two recursive calls. The worst case
time complexity of QUICKSORT is bad. However, for most inputs (or many
inputs), QUICKSORT runs even fast than MERGESORT.
This discussion motivates the derivation of the following QUICKHULL
algorithm, which is analogous to QUICKSORT, and has a bad worst case
time complexity and, in general a good \average time complexity".
Algorithm QUICKHULL(S)

BEGIN
1. Find the points p_min and p_max in S, with
the smallest and largest x-coordinates,
respectively;
2. Let S' be the subset of points in S that are
above the line L through p_min and p_max,
and let S'' be the set of points in S that
are below the line L;
3. Call UpperHULL(S', p_min, p_max) and
LowerHULL(S'', p_min, p_max);
4. Catenate the upper and lower hulls.
END.
Where the subroutines UpperHULL and LowerHULL are similar. We

only give the UpperHULL as follows.
Algorithm UpperHULL(S, l, r)
Given: a set S of points in the plane such that

all points in S are above the line L
through the points l and r.
Output: Find the the convex hull for S + {l, r}
BEGIN
1. Find a point p in S that is furthest to the
THE VORONOI DIAGRAM 63
line L;
2. Let S_1 be the subset of S that contains all
the points above the line through l and p,
and let S_2 be the subset of S that contains
all the points above the line through p and r;
3. Recursively call UpperHULL(S_1, l, p) and
UpperHULL(S_2, p, r);
4. Catenate the two parts obtained in Step 3;
END.
Similar to QUICKSORT, it can be proved that in the worst case, the

time complexity of the algorithm QUICKHULL is
(n2 ). While with a
reasonable assumption on the probability distribution of the points in the
set S , the running time of the algorithm QUICKHULL is O(n log n). We
leave the discussions to the interested reader.
5.2 The Voronoi diagram

We rst recall the denition of a Voronoi diagram.
Denition A Voronoi diagram of a set S = fp1; ; png of n points in
the plane is a partition of the plane into n regions V1, V2 , , Vn such that
any point in the region Vi is closer to the point pi than to any other point
in the set S .
The convex polygonal region Vi is called the Voronoi polygon of the point
pi in S . The vertices of the diagram are called Voronoi vertices and the line
segments of the diagram are called Voronoi edges. The Voronoi diagram of
a set S is denoted by Vor(S). Note that Voronoi vertices are in general not
the points in the set S .
We rst prove some interesting and important properties about Voronoi
diagrams. Throughout our proofs, we need to make a crucial assumption.
(This assumption can be eliminated but some properties will no longer hold
and the proofs will become much harder.)
ASSUMPTION
No four points in the set S are co-circular.
With this assumption, the Voronoi diagram has a simple structure.
e2
e1 V1
V2
e3
Vk
v
ek
Figure 5.1: A Voronoi vertex and its incident Voronoi edges
Lemma 5.2.1 Every Voronoi vertex has degree exactly three.

proof. Any Voronoi vertex is the intersection of a set of Voronoi edges.
Let e1 , e2, , ek be a sequence of Voronoi edges incident on a Voronoi vertex
v, such that the edge ei is common to the Voronoi polygons Vi?1 and Vi for
i = 2; 3; ; k, and edge e1 is common to the Voronoi polygons Vk and V1.
Without loss of generality, we suppose that Vi is the Voronoi polygon of the
point pi in the set S , for i = 1; ; k. See Figure 5.1.
Since the Voronoi vertex v is on e1 , v is equidistant from the points pk
and p1 . Similarly, since the Voronoi vertex v is on ei , for i = 2; ; k, v is
equidistant from the points pi?1 and pi . Therefore, v is equidistant from all
points pi , for i = 1; ; k. This implies that all these points pi , i = 1; ; k,
are on the circle whose center is v with the radius jvp1j. Since no four points
in the set S can be co-circular, we conclude k 3.
If k = 2, then both e1 and e2 are common to the Voronoi polygons V1
and V2. Hence they both belong to the perpendicular bisector of the segment
p1p2. Therefore, the vertex v is in fact an interior point of some Voronoi
edge, so it is not a Voronoi vertex, a contradiction.
Finally, if k = 1. Then both sides of the edge e1 are in the same Voronoi
polygon V1, so the Voronoi polygon is not convex, again a contradiction.
This proves that k must be exactly 3.
Suppose that we have constructed the Voronoi diagram for the set S of n
points in the plane. The following lemma tells us that for any point pi in S ,
pk e1
u
pi v pj
e
C
e2
Figure 5.2: The nearest points denes a Voronoi edge
the nearest point in S can be found by \locally" looking at the corresponding

Voronoi polygon Vi .
Lemma 5.2.2 The nearest neighbor of every given point pi in S has a
Voronoi edge that bounds the Voronoi polygon Vi of the point pi .
proof. Let pi and pj be two points in the given set S , and suppose
that pj is the nearest neighbor of pi . Let v be the midpoint of the segment
pi pj . Draw a circle C of radius jpi vj whose center is pi. We rst show that
the circle C is completely contained in the Voronoi polygon Vi . Suppose
otherwise that e were a Voronoi edge of Vi that contains a point u that is
in the interior of C . (See Figure 5.2.) Then e must lie on the perpendicular
bisector of a segment pi pk , where pk is a point in S and pk 6= pj (since the
perpendicular bisector of pi pj is tangent to the circle C ). Therefore, we must
have
jpipk j 2jpiuj < 2jpivj = jpipj j
So pi is closer to pk than to pj , contradicting the assumption that pj is the
nearest neighbor of pi .
Therefore, the circle C is completely contained in the Voronoi polygon
Vi. Since any point in the segment vpj is closer to pj than to pi and the point
v is on the circle C , the point v must be on the boundary of the Voronoi
polygon Vi . Now we show that v is an interior point of some Voronoi edge on
the boundary of Vi . Suppose otherwise, v is a Voronoi vertex. Let e1 and e2
be the Voronoi edges on the boundary of Vi such that e1 and e2 intersect at
v. Since Vi is convex, the angle 6 e1ve2 must be less than . See Figure 5.2.
But then at least one of the edges e1 and e2 intersects the interior of the
circle C . This is impossible by our discussion above. Therefore, there is
exactly one Voronoi edge e1 of Vi that passes through v . The edge e1 must
be tangent to the circle C otherwise e1 intersects the interior of the circle C .
Thus, the edge e1 is on the perpendicular bisector of the segment pi pj , i.e.,
the edge e1 is dened by the point pj .
For each Voronoi vertex v , by Lemma 5.2.1, there are exactly three
Voronoi polygons Vi, Vj , and Vk incident on v . Let pi , pj , and pk be the
three corresponding points in the set S . By the proof of Lemma 5.2.1, the
point v is equidistant from these three points pi , pj , and pk . Denote by C (v )
the unique circle dened by pi , pj , and pk . The circle C (v ) is centered at v
and has radius jvpi j.
Lemma 5.2.3 For any Voronoi vertex v, the circle C (v) contains no points
of the set S in its interior.
proof. Let pi , pj , and pk be the three points in the set S which dene
the circle C (v ). Then by the denition of C (v ), v is on the boundary of the
Voronoi polygons Vi, Vj , and Vk , which correspond to the points pi , pj , and
pk of the set S , respectively. Now by the denition of Voronoi polygons, in
the set S , the points pi , pj , and pk are the three closest points of the point
v. If there is another point ph in S that is in the interior of C (v), then v
would be closer to the point ph than to any of the three points pi , pj , and
pk . This is a contradiction.
Now we discuss the relationship between CONVEX HULL and the
Voronoi diagram.
Let r be a semi-innite ray originating from a nite point p0. For any
point p on the ray r, denote by rp the ray obtained by cutting away the
segment p0 p (excluding the point p) from the ray r.
Lemma 5.2.4 Two points in the set S are consecutive hull vertices of the
convex hull CH(S) if and only if the two corresponding Voronoi polygons
share a Voronoi edge that is a semi-innite ray.
proof. Let p1 and p2 be two points in the set S , and let V1 and V2 be the
two corresponding Voronoi polygons in Vor(S), respectively.
Suppose that the points p1 and p2 are two consecutive hull vertices of
the convex hull CH(S). Then the segment p1 p2 is an edge on the boundary
of the convex hull CH(S). Let l be the straight line that passes through the
segment p1 p2, then one side of l contains no points of the set S . Let r be a
semi-innite ray in the side of l that contains no points of S such that the
ray r is on the perpendicular bisector of the segment p1 p2, and originates
from the middle point of the segment p1 p2 . Let p be a point on the ray r,
draw a circle Cp centered at the point p with the radius jpp1j. Imagine that
the point p travels along the ray r toward innity. Then the radius of the
circle Cp is getting larger and larger and the circle Cp is getting closer and
closer to the straight line l (more precisely, for any xed point pl on the line
l, the circle Cp can be arbitrarily close to pl when the radius of the circle
Cp is large enough). Since no points of the set S are in the same side of the
line l as the point p, and the set S contains only nitely many points, there
must be a point p0 on the ray r such that for any point p on the ray r that
is beyond the point p0 , no points of the set S , except the points p1 and p2 ,
is contained in the interior or on the boundary of the circle Cp. That is, all
points on the ray r that are beyond the point p0 are closer to the points p1
and p2 than to any other points in the set S . By the denition of Voronoi
edges, therefore, the entire semi-innite ray rp0 must be contained in the
boundary of the Voronoi polygons V1 and V2. That is, the Voronoi polygons
V1 and V2 share a Voronoi edge that is a semi-innite ray.
Conversely, if the Voronoi polygons V1 and V2 share a Voronoi edge that
is a semi-innite ray r. Then every point on the ray r is equidistant from the
points p1 and p2, by the denition of a Voronoi polygon, thus the ray r is on
the perpendicular bisector of the segment p1 p2. Draw a circle Cp centered
at a point p on the ray r such that Cp passes through the points p1 and p2 .
Then for any point p on the ray r, the circle Cp contains no other points
of the set S in its interior. Let the point p travel along the ray r toward
innity, then the circle Cp is getting closer and closer to the straight line l
that passes through the segment p1 p2, and Cp never contains any points of
the set S in its interior. Since the set S is nite, we conclude that one side
of the line l contains no points of the set S . This implies that the segment
p1p2 is an edge on the boundary of the convex hull CH(S). Therefore, the
points p1 and p2 are consecutive hull vertices of the convex hull CH(S)1
Every hull vertex p of the convex hull CH(S) has a neighbor hull vertex p0 .
By Lemma 5.2.4, the corresponding Voronoi polygons V and V 0 share a semi-
1 For simplicity, we suppose that no three points of the set S are co-linear.
innite ray, therefore, the Voronoi polygon V corresponding to the point p
must be unbounded. Conversely, if a Voronoi polygon V is unbounded, then
V must share a semi-innite ray with another unbounded Voronoi polygon
V 0. Again by Lemma 5.2.4, the two corresponding points p and p0 of the
set S are consecutive hull vertices of the convex hull CH(S), therefore, the
point p corresponding to the Voronoi polygon V must be a hull vertex. This
proves the following corollary.
Corollary 5.2.5 A Voronoi polygon V of Vor(S) is unbounded if and only
if the corresponding point of the set S is a hull vertex of CH(S).
Finally, we need a lemma to consider how much space is needed to rep-
resent a Voronoi diagram of a set of n points in the plane.
Lemma 5.2.6 The Voronoi diagram contains at most 2n ? 3 vertices, 3n ? 5
edges and n regions.
proof. Since the regions of a Voronoi diagram Vor(S) are Voronoi poly-
gons that one-to-one correspond to the points of the set S , thus the Voronoi
diagram Vor(S) of the set S has exactly n regions.
Every semi-innite ray of the Voronoi diagram Vor(S) can be written in
the form (v; ), where v is the Voronoi vertex from which the ray originates
and is the polar angle of the ray. Introduce a new vertex w. Replace each
ray (v; ) of the Voronoi diagram Vor(S) by a nite edge (v; w), which may
be a curve, not necessarily a straight line. The resulting picture is a planar
imbedding I of a nite graph G that has the same number of regions and
the same number of edges as the Voronoi diagram Vor(S). The number of
vertices of I is one more than that of the Voronoi diagram Vor(S). Let V ,
E , and F be the number of vertices, the number of edges and the number
of regions of the imbedding I . By Euler's formula
V ?E+F = 2
By the above discussion, F = n. Moreover, we have 3V 2E since each
vertex of the graph G has degree at least 3 (note that there are at least
three semi-innite rays in the Voronoi diagram Vor(S), since the convex hull
CH(S) has at least three hull vertices, so by Lemma 5.2.4, Vor(S) has at
least three unbounded Voronoi polygons). Combining these two relations,
we get
V 2n ? 4
CONSTRUCTING VORONOI DIAGRAM 69
Remember that the number of vertices of the graph G is one more than that
of the Voronoi diagram Vor(S), we conclude that the number of vertices of
the Voronoi diagram Vor(S) is at most 2n ? 3.
Now apply Euler's formula again, we obtain
E 3n ? 5
Therefore, the number of vertices, the number of edges, and the number
of regions of a Voronoi diagram are all of order O(n).
We can use the Doubly-Connected Edge List (DCEL), as introduced in
Section 1.4 to represent in computers a Voronoi diagram of a set of points
in the plane. For this we need a slight generalization. For each unbounded
Voronoi polygon V in a Voronoi diagram, we call the semi-innite ray r of
V the rst ray of V if when we travel from innity along the ray r toward
the Voronoi vertex from which r originates, the region V is on our right.
The other semi-innite ray of V is called the last ray of V . Now given a
semi-innite ray r of a Voronoi diagram, suppose that r is the last ray of
a Voronoi polygon Vi . Then in the edge node corresponding to the ray r,
the pointer P 2 will point to the semi-innite ray that is the rst ray of the
Voronoi polygon Vi. Moreover, each region V , which is a Voronoi polygon
of the Voronoi diagram, can be named by its corresponding point in the set
S.
5.3 Constructing the Voronoi diagram

In this section, we present an algorithm that constructs the Voronoi diagram
given a set S of n planar points. The algorithm runs in time O(n log n).
The algorithm is the standard divide-and-conquer method. We rst give
a rough sketch of the algorithm as follows.
Algorithm VORONOI DIAGRAM

Output: the Voronoi diagram Vor(S) of S
BEGIN
1. Presort the points in the set S by x-coordinate;
70 VORONOI DIAGRAM
2. Call the subroutine Voronoi(S)
END.
Where the subroutine Voronoi(S) is given as follows.
Algorithm Voronoi(S)
Given: a set S of n points in the plane, sorted

by x-coordinates
Output: the Voronoi diagram Vor(S) of S
BEGIN
1. Split the set S into two approximately equal
size subsets S_L and S_R by a vertical line
L such that all points in S_L are in the left
side of L and all points in S_R are in the
right side of L;
2. Recursively call Voronoi(S_L) and Voronoi(S_R);
3. Merge Vor(S_L) and Vor(S_R) to construct Vor(S).
END.
Step 1 in the algorithm Voronoi(S) can be done in linear time, since the
given set S is sorted by x-coordinate. If the merge part (Step 3) in the
algorithm Voronoi(S) can also be done in linear time, then by the standard
technique in Algorithm Analysis, the algorithm Voronoi(S) runs in time
O(n log n). Consequently, the algorithm VORONOI DIAGRAM runs in time
O(n log n).
Therefore, the problem of constructing the Voronoi diagram of the set
S in time O(n log n) is reduced to the problem of merging in linear time
the two Voronoi diagrams Vor(SL) and Vor(SR) into the Voronoi diagram
Vor(S), where SL and SR are two sets separated by a vertical line l and
SL [ SR = S .
Consider the Voronoi diagrams Vor(S), Vor(SL), and Vor(SR). We rst
discuss what of Vor(S) can be missing in Vor(SL) and Vor(SR). Let e be
a Voronoi edge of Vor(S) dened by two points pi and pj of S , that is, e is
a Voronoi edge on the boundary between the Voronoi polygons Vi and Vj
of the points pi and pj , respectively. By the denition of Voronoi polygons,
the points pi and pj are the closest points in the set S to the points on the
edge e. If both pi and pj are in the set SL, then the points pi and pj must
be the closest points in the set SL to the points on the edge e since the set
SL is a subset of the set S . Therefore, the edge e must be also present in the
Voronoi diagram Vor(SL ), either as a Voronoi edge or as part of a Voronoi
edge of Vor(SL). Similarly, if both pi and pj are in the set SR, then the edge
e must be also present in the Voronoi diagram Vor(SR), either as a Voronoi
edge or as part of a Voronoi edge of Vor(SR). Therefore, a Voronoi edge e
of Vor(S) that is missing in both Vor(SL) and Vor(SR) must be dened by
two points such that one is in the set SL and the other is in the set SR.
Let be the subgraph of Vor(S) that consists of the Voronoi edges of
Vor(S) that are dened by the pairs (pi; pj ) of points in S such that pi 2 SL
and pj 2 SR . We do not presume that is a connected graph. We rst
discuss what looks like.
Lemma 5.3.1 Each vertex of has degree exactly 2.
proof. Since each vertex v of is also a Voronoi vertex of Vor(S), by
Lemma 5.2.1, the degree of v is at most 3 in . Suppose that e1 , e2 , and
e3 are the three Voronoi edges incident at v in the Voronoi diagram Vor(S),
and that V1, V2, and V3 are the Voronoi polygons incident at v such that e1
is between V1 and V2 , e2 is between V2 and V3, and e3 is between V3 and V1 .
Let p1 , p2, and p3 be the three points in the set S that correspond to the
Voronoi polygons V1, V2, and V3, respectively.
If the vertex v has degree 3 in , then all Voronoi edges e1 , e2 , and e3
are in . Since e1 is in , by the denition of , without loss of generality,
we can suppose that the point p1 is in the set SL and the point p2 is in the
set SR. Then because e2 is between V2 and V3 and e2 is in , the point p3
must be in the set SL . Finally, because e3 is between V3 and V1 and e3 is
in , we must also have that p1 is in SR . This gives us a contradiction that
the point p1 is in both sets SL and SR. Therefore, the vertex v cannot have
degree 3 in .
If the vertex v has degree 1 in . Then suppose that the unique Voronoi
edge that is incident on v and in is e1 . Thus we can suppose, without loss
of generality, that the point p1 is in the set SL and the point p2 is in the set
SR . However, now if the point p3 is in the set SL then the edge e2 should be
in , while if the point p3 is in the set SR, then the edge e3 should be in ,
either case contradicts the assumption that the vertex v has degree 1 in .
This proves that each vertex of has degree 2 in .
Therefore, each connected component of is either a closed simple cycle,
or a simple chain whose both ends are semi-innite rays.
72 VORONOI DIAGRAM
v1 p2
v2
v
p1
l
v p3 l
v1 v2
v3
Figure 5.3: A horizontal line separating v from v1 and v2 .
Recall that a chain C is said to be monotone if any horizontal line inter-

sects the chain C in exactly one point.
Lemma 5.3.2 Every connected component of is monotone. In other
words, every horizontal line cuts a connected component of at exactly one
point.
proof. First we prove that no edge in can be horizontal. Suppose that
an edge e in is horizontal. Let pL and pR be the two points in the set S
that dene the edge e, pL 2 SL and pR 2 SR . Then the segment pL pR is
vertical, contradicting the fact that the sets SL and SR are separated by a
vertical line.
Now suppose that a connected component C of is not monotone. Since
each vertex in has degree exactly 2 (Lemma 5.3.1), we must be able to
nd a vertex v on C whose two adjacent vertices are v1 and v2 such that a
horizontal line l separates v from v1 and v2 . See Figure 5.3.
Without loss of generality, suppose that v is below the line l, and that v1
and v2 are above the line l. The vertex v is a Voronoi vertex in the Voronoi
diagram Vor(S), and v1 and v2 are two adjacent Voronoi vertices in Vor(S).
Suppose that the third Voronoi vertex adjacent to v is v3 . The vertex v3
must be below the horizontal line l since each Voronoi polygon has to be
convex and each Voronoi vertex has degree exactly 3, by Lemma 5.2.1. Let
p1 , p2 , and p3 be the three points in the set S , such that edge fv; v1g is
dened by p1 and p2, the edge fv; v2g is dened by p2 and p3 , and the edge
fv; v3g is dened by p3 and p1. See Figure 5.3. Without loss of generality,
suppose that the point p2 is in the set SL , then both points p1 and p3 are
in the set SR . However, it is easy to see that we can draw two vertical lines
l1 and l2 such that p1 is on the left side of l1 and p2 is on the right side of
p2 e
p1
C1 C2
Figure 5.4: Two separated chains in
l1 , while p2 is on the left side of l2 and p3 is on the right side of l2. But
this contradicts the assumption that the sets SL and SR are separated by a
vertical line.
This proves that the connected component C of must be monotone.
So no connected component of can be a cycle. Finally, we investigate

how many connected components can have.
Lemma 5.3.3 The graph has exactly one connected component.
proof. First at all, must have at least one connected component since
the Voronoi diagram is connected, so there is at least one Voronoi edge that
bounds two Voronoi polygons corresponding to a pair of points that are from
the sets SL and SR , respectively.
Now suppose that there are more than one connected components in
. By Lemma 5.3.1 and Lemma 5.3.2, all these connected components are
monotone chains, and no two of them intersect. Let C1 and C2 be the two
adjacent chains in , i.e., there is no other chain in that is between the
slice bounded by C1 and C2. Suppose also that C1 is on the left of C2 . See
Figure 5.4. Then all Voronoi polygons of Vor(S) that are between C1 and
C2 correspond to points in a single set of SL and SR. Suppose all of them
correspond to points in set SL . Now look at any edge e on C1 . The edge
e must be dened by a point p1 that is between the slice of C1 and C2 and
thereby in the set SL and a point p2 that is on the left side of C1. See
Figure 5.4. By the denition of , the point p2 is in the set SR. It is easy
74 VORONOI DIAGRAM
to see that there is a vertical line such that the point p2 is on its left while
the point p1 is on its right. However, this contradicts the fact that all points
in SR should be on the right of all points in SL . On the other hand, if all
Voronoi polygons between C1 and C2 correspond to points in the set SR ,
then we can similarly derive a contradiction by considering an edge on the
chain C2.
This proves that consists of a single monotone chain.
Since is a single monotone chain, and two end edges of must be semi-
innite rays, we can talk about the \left side" and the \right side" of the
chain . By the discussion above, we know that only the edges in could
be missing in the Voronoi diagrams Vor(SL ) and Vor(SR). Thus, we need
to add the chain to the graph Vor(SL) [ Vor(SR ) to construct the Voronoi
diagram Vor(S).
Now we discuss what should be deleted from Vor(SL ) and Vor(SR) in
order to construct Vor(S).
Lemma 5.3.4 Let e be a Voronoi edge or part of a Voronoi edge of Vor(SL).
The edge e disappears in Vor(S) if and only if e entirely lies on the right side
of . Similarly, if e0 is a Voronoi edge or part of a Voronoi edge of Vor(SR),
then e0 disappears in Vor(S) if and only if e entirely lies on the left side of
.
proof. First of all, no point in SL can be on the right side of , otherwise,
we would be able to nd a point p in SL such that the Voronoi polygon of p
has a boundary edge e on . This would give a point in the set SR that is
on the left of the point p, contradicting the denition of the sets SL and SR .
Let e be a Voronoi edge or part of a Voronoi edge of Vor(SL) that entirely
lies on the right side of . Let e be dened by two points p1 and p2 in the
set SL . If e is present in the Voronoi diagram Vor(S), then the closest points
in S to a point p on the edge e would be p1 and p2. That is, the point p
is in (the boundary of) the Voronoi polygon V1 in Vor(S) that corresponds
to the point p1. Since V1 must be convex, the segment p1 p must be in V1 .
Moreover, since the point p1 is in the interior of V1 , the segment p1p in fact
does not intersect any Voronoi edges in Vor(S) except the edge e. However,
since the point p1 is on the left side of and the point p is on the right
side of , and partitions the plane into two separated parts, the segment
p1p must intersect at some point. That is, the segment p1p must intersect
some Voronoi edge of Vor(S) that is not e, since e is dened by two vertices
in SL while each edge on is dened by a point in SL and a point in SR .
This is a contradiction. Therefore, the edge e of Vor(SL) must disappear in
Vor(S).
This actually proves that for any point p on the right side of , the closest
point in the set S must be a point in the set SR .
Similarly, a Voronoi edge or part of a Voronoi edge of Vor(SR) that
entirely lies on the left side of disappears in Vor(S).
On the other hand, let e be a Voronoi edge or part of a Voronoi edge of
Vor(SL) that lies entirely on the left side of . Suppose that e is dened
by two points p1 and p2 in the set SL . By the discussion above, the closest
points in S to the points of e are still the points in the set SL . Therefore,
the two closest points in the set S to the points in e are still the points p1
and p2 . That is, e is still on the boundary of the two Voronoi polygons V1
and V2 in Vor(S) corresponding to the points p1 and p2 , respectively, i.e., e
is still present in the Voronoi diagram Vor(S).
This completes the proof.
By Lemmas 5.3.1, 5.3.2, 5.3.3, and 5.3.4, we can use the following algo-
rithm to construct the Voronoi diagram Vor(S) from the Voronoi diagrams
Vor(SL) and Vor(SR).
Algorithm MERGE(Vor(S_L), Vor(S_R))
Given: the Voronoi diagrams Vor(S_L) and Vor(S_R)

Output: the Voronoi diagram Vor(S)
BEGIN
1. Construct the separating chain SIGMA;
2. Delete all edges and partial edges of Vor(S_L) that are
entirely on the right side of SIGMA;
3. Delete all edges and partial edges of Vor(S_R) that are
entirely on the left side of SIGMA;
END.
None of the steps can be obviously done in linear time. In the remaining
of this section, we will discuss how to construct the separating chain . At
the meantime, we nd all intersections of with Vor(SL) and Vor(SR), and
delete the proper edges and partial edges from Vor(SL) and Vor(SR).
First we consider how to construct the two semi-innite rays of the chain
. Let the two semi-innite rays of the chain be l1 and l2. Suppose that
76 VORONOI DIAGRAM
l1 is the Voronoi edge of Vor(S) that is shared by two unbounded Voronoi
polygons V1 and V2 of two points p1 and p2 in the set S , respectively. By
Lemma 5.2.4, the points p1 and p2 are two consecutive hull vertices of the
convex hull CH(S), and the ray l1 is on the perpendicular bisector of the
segment p1p2 . Since l1 is in , we can suppose that the point p1 is in the
set SL and the point p2 is in the set SR . Therefore, the segment p1p2 is in
fact a supporting bridge of the two convex hulls CH(SL) and CH(SR) (see
Section 4.1 and note that the two sets SL and SR are separated by a vertical
line). Similarly, the ray l2 is on the perpendicular bisector of the other
supporting bridge of the two convex hulls CH(SL) and CH(SR). Therefore,
if the two convex hulls CH(SL) and CH(SR) are known, then we can nd the
two bridges of CH(SL) and CH(SR) in linear time (see Section 4.1). With
these two bridges, the two semi-innite rays of can be found in constant
time. Note that at meantime, we have also constructed in linear time the
convex hull CH(S) of the set S as a by-product, which can be used for the
later induction steps. Therefore, the algorithm of constructing the chain
looks as follows.
Algorithm CONSTRUCTING-SIGMA
Given: the Voronoi diagrams Vor(S_L) and Vor(S_R)

and the convex hulls CH(S_L) and CH(S_R)
Output: the separating chain SIGMA and the convex
hull CH(S)
BEGIN
1. Find the upper bridge b_u and the lower bridge
b_l of the two convex hulls CH(S_L), CH(S_R);
2. Construct the perpendicular bisectors l_u and
l_l of the bridges b_u and b_l, respectively;
3. With the bridges b_u and b_l, construct the
convex hull CH(S);
4. traverse the chain SIGMA in the direction of
decreasing y, starting from the infinite end
of the upper ray l_u of SIGMA, construct SIGMA
edge by edge, until the lower ray l_l is
reached;
END.
Step 1 and Step 3 can be done in linear time, by the discussion of Sec-
tion 4.1. Step 2 can be easily done in constant time. We must discuss how
Step 4 is done in linear time. In the meantime, we also have to discuss how we
nd the intersections of with the Voronoi diagrams Vor(SL) and Vor(SR),
and delete proper edges and partial edges from Vor(SL ) and Vor(SR) and
construct the Voronoi diagram Vor(S).
Remember that we can use Doubly-Connected-Edge-List (DCEL) to rep-
resent a Voronoi diagram. We suppose that the Voronoi diagrams Vor(SL )
and Vor(SR) are represented by two DCELs. Moreover, we suppose that
the rotation of edges incident on each vertex of Vor(SL) is given in coun-
terclockwise order in the corresponding DCEL, while the rotation of edges
incident on each vertex of Vor(SR) is given in clockwise order. Therefore,
the regions of Vor(SL) will be traced clockwise, while the regions of Vor(SR)
will be traced counterclockwise, by the algorithm TRACE-REGION given
in Section 1.4.
Now suppose inductively that we are traversing the chain in the di-
rection of decreasing y , and we are in the intersection area of the Voronoi
polygon VL of Vor(SL) of some point pL 2 SL and the Voronoi polygon VR
of Vor(SR) of some point pR 2 SR . Since in this area, the closest point of
SL is pL and the closest point of SR is pR , we must follow the perpendicular
bisector of the segment pL pR , in the direction of decreasing y . Suppose along
this direction, we are traversing an edge e0 in . We keep going along this
direction until we hit an Voronoi edge e of Vor(SL) or of Vor(SR). Without
loss of generality, suppose that e is a Voronoi edge of Vor(SR). The edge e
is on the boundary of the Voronoi polygon VR , so e must be dened by the
point pR and another point p0R 2 SR . Let the Voronoi polygon of the point
p0R in Vor(SR) be VR0 . If we keep going the same direction, we will cross the
edge e and enter the Voronoi polygon VR0 of Vor(SR). Now the closest point
in the set SR is the point p0R. The closest point in the set SL is still the point
pL. Therefore, to continue traversing the chain , we should go along the
perpendicular bisector of the segment pL p0R , in the direction of decreasing y .
To make this change, at the intersection of the chain and the edge e, we
simply switch our direction from the perpendicular bisector of pL pR to the
perpendicular bisector of pLp0R , both in the direction of decreasing y . Now
we are on the next edge of the chain . We inductively work in this way to
nd the next edge of the chain , and so on, until we hit the low ray ll of .
Note that we have no diculty to initialize this process. We can start
at a point p on the upper ray lu that is \far enough" from the upper bridge
bu = (pL; pR), where pL 2 SL and pR 2 SR. Then we must be in the
intersection area of the Voronoi polygon of pL in Vor(SL) and the Voronoi
78 VORONOI DIAGRAM
polygon of pR in Vor(SL).
Summarizing this discussion, we get the following algorithm.
Algorithm CONSTRUCTING-SIGMA
BEGIN
1. Let p_0 be a point on the upper ray l_u that
is far enough from the upper bridge
b_u = (p_L, p_R), where p_L is in S_L, and
p_R is in S_R. Let l_0 be the semi-infinite
ray originating from the point p_0 that has
the opposite direction of the ray l_u, and let
V_L and V_R be the Voronoi polygons of the
points p_L and p_R in the Voronoi diagrams
Vor(S_L) and Vor(S_R), respectively;
2. IF l_0 is not identical with the lower ray l_l
THEN
2.1. Compute the point q_L that is the intersection
of l_0 with the boundary of V_L, and compute
the point q_R that is the intersection of l_0
with the boundary of V_R;
2.2 IF p_0 is closer to q_L than to q_R, THEN
suppose that the point q_L is on a Voronoi edge
e_L of Vor(S_L) that is defined by the point
p_L and another point p_L' in S_L, then let
p_0 = q_L, and let l_0 be the semi-infinite ray
originating from q_L that is on the perpendicular
bisector of the segment {p_L', p_R} in the direction
of decreasing y. Finally, let the current Voronoi
polygon V_L of Vor(S_L) be the Voronoi polygon of
the point p_L';
2.3. IF p_0 is closer to q_R than to q_L THEN
update the parameters p_0, l_0, and V_R similarly;
3. Go back to Step 2.
END.
As we mentioned before, Step 1 can be done in constant time when we

know the upper and lower bridges of the convex hulls CH(SL) and CH(SR).
The loop of Step 2 - Step 6 can be executed at most O(n) times since each
execution of the loop nds one more edge on the chain and as a subgraph
of Vor(S), the chain contains at most O(n) edges. Within each execution
of the loop, Step 4 and Step 5 take at most constant time since we only need
some local modications.
The remaining question is how much time is needed to nd the intersect-
ing points qL and qR in each execution of the loop of Step 2 - Step 6.
Knowing p0 , l0, VL and VR , we can trace the boundary edges of the poly-
gon VL to nd a boundary edge of VL that contains the point pL . Similarly
we can nd the point pR . However, since the chain can contain up to
(n)
edges and the polygons VL and VR can have up to
(n) boundary edges,
this straightforward algorithm would run in time
(n2) to nd the chain .
Therefore, in order to construct in linear time, we must not trace each
Voronoi polygon of the Voronoi diagrams Vor(SL) and Vor(SR) too many
times during the entire process of constructing the chain .
Lemma 5.3.5 Suppose that the chain is traversed in the direction of de-
creasing y . Let VL be a Voronoi polygon of the Voronoi diagram Vor(SL). If
the chain makes a turn at an interior point of VL, then the turn must be
a right turn. Similarly, if the chain makes a turn at an interior point of
some Voronoi polygon of Vor(SR), then the turn must be a left turn.
proof. Suppose that the point in SL corresponding to the Voronoi polygon
VL in Vor(SL) is pL. Let v1 v2v3 be a turn of the chain in the direction
of decreasing y , where v2 is an interior point of VL . Then vertices v1 and
v3 are also in VL, since at an exit of VL, the chain must make another turn.
(However, v1 and v3 may be on the boundary of VL .) Since VL is convex, the
segments v1v2 and v2 v3 are entirely contained in VL. Therefore, the closest
point in the set SL to the points on v1v2 and v2v3 is still pL . Let V be
the Voronoi diagram of the point pL in the Voronoi diagram Vor(S). By the
denition of the chain , the segments v1 v2 and v2 v3 are two consecutive
boundary edges of V . When we traverse from v1 to v2 then to v3, the point
pL must be on our right, because v1v2 and v2v3 are on the chain and all
points of SL are on our right when we traverse in the direction of decreasing
y. Since V is a convex polygon, the turn we make at the point v2 must be
a right turn.
By this lemma, we can nd the point qL and qR in the algorithm
CONSTRUCTING-SIGMA as follows. Suppose that we entered the Voronoi
polygon VL at the point p0 , which is on a boundary edge e0 of VL . Starting
from the edge e0 , trace the region VL clockwise, using the algorithm TRACE-
REGION in Section 1.4, until we nd the boundary edge eL that intersects
80 VORONOI DIAGRAM
e0 p0
VL
qR l0
new l 0
eL qL
Figure 5.5: makes only right turn in VL
the ray l0 at point qL . (Note there is only one such a boundary edge of VL .)
Similarly nd the point qR . If the point p0 is closer to the point qR than to
the point qL , then the chain makes a turn at the point qR . Since the point
qR is in the interior of VL, by Lemma 5.3.5, the turn of at qR must be a
right turn. We modify the parameters p0 , l0 , and VR properly. Now we have
to nd the intersection of the new l0 with VL again. However, since the turn
of the chain at the point qR is a right turn, the new l0 cannot intersect any
edges between the edges e0 and eL we have already traced. See Figure 5.5.
Therefore, to nd the intersection of VL and the new l0, we can trace the
region VL starting from the edge eL . If the chain eventually exits VL, then
we must come to an exit edge eE of VL for before we trace back to the
edge e0 . Therefore, to traverse the partial chain of in the Voronoi polygon
VL from the entering edge e0 to the exit edge eE , we only have to trace the
boundary edges of VL between the edge e0 and the edge eE clockwise.
This is still not the end, however. Although traversing a continuous
partial chain of in the Voronoi polygon VL can be done eciently, there
may be more than one continuous partial chain of that are contained in
the Voronoi polygon VL. We must prove that traversing all these continuous
partial chains of in VL can also be done eciently. Let P1 and P2 be two
continuous partial chains of such that P1 enters VL at an edge e0 and exits
VL at an edge eE , while P2 enters VL at an edge e00 and exits VL at an edge
e0E . As we discuss above, to traverse P1, we need to trace the boundary edges
of VL between the edge e0 and eE clockwise. As we explained in the proof
of Lemma 5.3.5, the partial chains P1 and P2 are all on the boundary of the
Voronoi polygon V of the point pL in the Voronoi diagram Vor(S). Since
all turns on P1 are right turn, the area in VL between P1 and the partial
boundary of VL we have traced is excluded from the Voronoi polygon V of
the point pL in the Voronoi diagram Vor(S). Now the partial chain P2 is
also on the boundary of the Voronoi polygon V , so P2 cannot enter or exit
VL from an edge that is between e0 and eE . Therefore, the edges e00 and e0E
must be among those untraced boundary edges of VL (including the edges
e0 and eE ). In other words, the sequence of the boundary edges of VL we
trace for P1 and the sequence of the boundary edges of VL we trace for P2
are internally disjoint. This conclusion is easily generalized to more than
two continuous partial chains of in the Voronoi polygon VL .
Therefore, for a boundary edge of VL at which no partial chain of
enters or exits, our algorithm traces it at most once. On the other hand, for
a boundary edge of VL at which some partial chains of enter and/or exit,
each visit of the edge produces a new edge on the chain . Therefore, the
total time of the traversing of the chain is bounded by O(n + mL ), where
n is the number of edges on the chain , and mL is the sum of the region
sizes over all regions of Vor(SL). Since n is bounded by n, the number of
points in the set S , and mL equals two times the number of edges of Vor(SL),
which is bounded by 3n, by Lemma 5.2.6, the total time to construct the
chain is bounded by O(n).
The traversing of the chain in a Voronoi polygon VR of the Voronoi
diagram Vor(SR) can be done symmetrically. Here since the rotation of
edges incident on each vertex of Vor(SR) is clockwise in the DCEL, the
regions of Vor(SR) are traced counterclockwise. Completely similar as we
did in Lemma 5.3.5, we can prove that if makes a turn at an interior point
of VR , then the turn must be a left turn. Therefore, the chain can also be
traversed eciently in the Voronoi polygons of Vor(SR ), and the total time
is also bounded by O(n).
Finally we explain how to delete the edges and partial edges of Vor(SL )
that are on the right side of and the edges and partial edges of Vor(SR)
that are on the left side of . Note that when we traverse the chain in the
direction of decreasing y , we can nd all intersections of with the Voronoi
diagrams Vor(SL) and Vor(SR). Therefore, it is easy for us to decide which
part of the Voronoi diagrams should be thrown away.
Therefore, we conclude that the running time of the algorithm MERGE(
Vor(SL), Vor(SR)) is O(n). Consequently, the running time of the algorithm
VORONOI DIAGRAM is O(n log n).
82 VORONOI DIAGRAM
Theorem 5.3.6 Given a set S of n points in the plane, the Voronoi diagram
of S can be constructed in time O(n log n).
Chapter 6
Prune and Search

Prune and Search is a technique originally used for nding medians developed
by Blum, Floyd, Pratt, Rivest, and Tarjan [5]. The technique, as applied to
median nding, throws out a constant fraction of the numbers during each
iteration of a loop. Solving the recurrence gives us an O(n) time algorithm
for nding a median.
Let us have a more detailed review of the above algorithm. To nd the
median of a list, we rst generalize the problem a little bit. We consider
the problem of nding the kth smallest number of a list L of n numbers, for
an arbitrary k. We rst divide the n numbers into n=5 groups, each of 5
numbers, then nd the median for each of the groups. Let L0 be the list of
these n=5 medians. Recursively nd the median m of the list L0 . It can be
proved that m is greater than or equal to at least one fourth of the numbers
in the original list L, and also less than or equal to at least one fourth of the
numbers in the original list L. Therefore, the number m partitions the list
L into two sublists L1 and L2 such that all numbers in L1 are less than or
equal to m and all numbers in L2 are greater than or equal to m. Moreover,
the size of each of these two sublists L1 and L2 is at least one fourth of
the original list L. Now if the sublist L1 contains at least k numbers, then
recursively call the algorithm to nd the kth smallest number in the list L1 .
On the other hand, if the sublist L1 contains h numbers such that h < k,
then recursively call the algorithm to nd the (k ? h)th smallest number in
the sublist L2 . In any case, the size of the sublist we are going to work on is
at most three fourth of the size of the original list L. The detailed discussion
of this algorithm can be found in [2], Section 3.5.
Let us analyze the above Median Finding algorithm. Suppose that the
83
84 PRUNE AND SEARCH
time complexity of the algorithm is T (n) on inputs of size n. Then to nd
the median of the list L0 of the n=5 medians takes time T (n=5). Since both
lists L1 and L2 are of size at most 3n=4, to nd the kth smallest number
in the list L1 or to nd the (h ? k)th smallest number in the list L2 takes
time at most T (3n=4). It is also clear that the computation for the rest of
the algorithm can be done in time bn, where b is a constant. Therefore, the
function T (n) satises the following recurrence.
T (n) = T (n=5) + T (3n=4) + bn
Let g be an integer such that g 20b and g T (1), then it is not dicult
to prove, by induction, that
T (n) gn
That is, T (n) = O(n).
A general form of a prune and search algorithm can be described, infor-
mally, as following.
Algorithm PRUNE AND SEARCH
Given: a problem P of size n

Output: a solution S of the problem
BEGIN
0. IF the size n of P is small
Solve P directly and STOP;
1. `Prune' the problem P into k smaller problems
P1, P2, ..., Pk, of size (c_1)n, (c_2)n, ...,
(c_k)n, respectively, such that
(c_1) + (c_2) + ... + (c_k) <= c < 1
where c is a fixed constant;
2. Recursively solve the problems P1, P2, ..., Pk;
3. Use the results of Step 2 to derive a solution
for the problem P;
END.
Suppose that the time complexity of the algorithm PRUNE AND

SEARCH is T (n), and suppose that Step 1 and Step 3 of the algorithm
take time F (n). Then the function T (n) can be represented by the following
recurrence:
T (n) = T (c1n) + T (c2) + + T (ck ) + F (n)
KIRKPATRICK-SEIDEL'S ALGORITHM 85
The time complexity T (n) of the algorithm PRUNE AND SEARCH can
be obtained by solving the above recurrence. In particular, if the function
F (n) is O(n), then it can be proved that the function T (n) is also O(n).
6.1 Kirkpatrick-Seidel's algorithm for convex

hulls
We present a prune and search algorithm for constructing convex hulls, which
is due to Kirkpatrick and Seidel [13].
Let us rst consider the following problem.
Problem:
given two sets SL and SR of points in the plane, such that there is a
vertical line l such that SL is on the left of l and SR is on the right of l, how
do we nd the upper bridge of SL and SR , i.e., the line passing through a
point in SL and a point in SR such that all points in SL and SR are on or
below the line?
In the algorithm MERGEHULL, we know that when the convex hulls
of both sets SL and SR are known, the upper bridge can be constructed in
linear time by lifting a line segment between SL and SR until the segment
cannot be lifted anymore. However, constructing the convex hulls for SL and
SR itself takes
(n log n) time, which is too much to us. What we expect is
a linear time algorithm solving this problem.
The prune and search technique is used to solve the above problem. The
main idea involves nding a \suitable" line in O(n) time, a line that allows
us to throw away a constant fraction of the points as candidates for the
bridge. We then recurse on the remaining points.
Denition An upper supporting line of a set S of points in the plane
contains at least one point of S , and all points of S lie below or on the line.
Now let Lp be an upper supporting line of the set SL [ SR passing through

a point p of SL , and suppose that Lp is not an upper bridge of SL and SR ,
also let p0 q 0 be a line segment where p0; q 0 2 SL [ SR . If the slope of p0 q 0
is not less than the slope of Lp , then it is easy to see that the line segment
p0 q 0 cannot be contained in the upper bridge of SL and SR. In particular,
the point p0 cannot be on the upper bridge. Similarly, if Lq is an upper
supporting line of the set SL [ SR passing through a point q of SR , and
86 PRUNE AND SEARCH
suppose that Lq is not an upper bridge of SL and SR, and p00q 00 is a line
segment where p00; q 00 2 SL [ SR . If the slope of p00q 00 is not larger than the
slope of Lq , then the line segment p00q 00 cannot be in the upper bridge of SL
and SR. In particular, the point q 00 cannot be on the upper bridge.
This crucial observation gives us the following algorithm to solve the
above problem.
Algorithm UpperBridge(S, l)
Given: a set S of n points in the plane and a vertical

line l separating S into a left subset S_L and
a right subset S_R
Output: the upper bridge of the sets S_L and S_R
BEGIN
1. Arbitrarily pair up the points of S:
(p_1, q_1), (p_2, q_2), ..., (p_{n/2}, q_{n/2});
2. Let the slope of the segment [p_i, q_i] be s_i,
i = 1, ..., n. Using the Median Finding
algorithm to find a pair (p_l, q_l) such that
the slope s_l of it is the median in
s_1, s_2, ..., s_{n/2};
3. Construct an upper supporting line L with the
slope s_l. To do this, draw a line with the
slope s_l through each point in S. Then take
the line that has the highest intersection with
the y-axis;
4. If L passes through points in both S_L and S_R,
then L is the upper bridge we want, so we stop
and return; Otherwise, we do the following steps;
5. If L passes through only points in S_L, then scan
the list of pairs (p_i, q_i) we made in Step 1.
If the slope of a segment [p_i, q_i] is not less
than the slope of the supporting line L, then
throw away the point p_i;
6. If L passes through only points in S_R, then scan
the list of pairs (p_i, q_i) we made in Step 1.
If the slope of a segment [p_i, q_i] is not larger
than the slope of the supporting line L, then
throw away the point q_i;
7. Let S' be the set of the remaining points of S,
recursively call UpperBridge(S', l).
END.
KIRKPATRICK-SEIDEL'S ALGORITHM 87
The correctness of the algorithm UpperBridge can be proved using the
discussion preceding the algorithm: we never delete the points on the upper
bridge. Now let us consider the time complexity of the algorithm. Step 1,
Step 3 and Step 4 can be obviously done in time O(n). Step 2 can be done
in linear time using the Median Finding algorithm described before. Now let
us consider how many points are left for the recursive call of the algorithm
in Step 7. Since the slope sl of L is the median of the slopes of the segments
pi qi , for i = 1; ; n=2, if Step 5 is executed, at least half of the segments piqi
have a slope not less than sl . So the corresponding points pi are thrown away.
Therefore, at least one fourth of the points in S are thrown away. Similarly,
if Step 6 is executed, also at least one fourth points in S are thrown away.
Therefore, at most three fourth points in S are left for the recursive call in
Step 7. Let T (n) be the time complexity of the algorithm UpperBridge, then
we have the following recurrence relation:
T (n) = O(n) + T ( 34n )
It is easy to obtain that T (n) = O(n). Therefore, the algorithm UpperBridge
runs in linear time.
With this preparation, now we are able to present Kirkpatrick-Seidel
algorithm as follows.
Algorithm KIRKPATRICK-SEIDEL(S)

BEGIN
1. Let p_min and p_max be the points in S with
the smallest and the largest x-coordinates,
respectively, let the line through p_min and
p_max be L;
2. Split the set S into two subsets S' and S'',
such that S' is the set of points of S above
the line L, and S'' is the set of points of
S below the line L;
3. Call UpperHull(S', p_min, p_max);
4. Call LowerHull(S'', p_min, p_max);
END.
88 PRUNE AND SEARCH
Step 1 and Step 2 of the algorithm KIRKPATRICK-SEIDEL can be done
in linear time. The subroutines UpperHull and LowerHull are similar. We
only discuss the subroutine UpperHull as follows.
Algorithm UpperHull(S, p_min, p_max)
Given: a set S of n points in the plane that

are all above the line through the
points p_min and p_max, which are also
points in S
Output: the upper hull of the set S
BEGIN
1. Using the Median Finding algorithm to find a
vertical line L_d which divides the set S
into two equal size subsets S_L and S_R;
2. Call UpperBridge(S, L_d) to construct the
upper bridge [p_l p_r] of S_L and S_R, where
p_l is in S_L and p_r is in S_R;
3. Let S' be the set of points in S that are
above the line through p_min and p_l, and let
S'' be the set of points in S that are above
the line through p_r and p_max;
4. Recursively call UpperHull(S', p_min, p_l) and
UpperHull(S'', p_r, p_max);
5. Merge the results of Step 4 with the upper
bridge [p_l p_r] properly;
END.
Now let us consider the time complexity of the algorithm UpperHull.

Suppose that there are k points of the set S on the convex hull CH(S). Let
T (n; k) be the time complexity of the algorithm. Step 1 takes time O(n)
by the Median Finding algorithm. Step 2 takes time O(n) by our analysis
of the algorithm UpperBridge. Step 3 and Step 5 can be obviously done in
time O(n). Now suppose that there are k0 hull vertices of CH(S) contained
in the set S 0, and k00 hull vertices of CH(S) contained in the set S 00. Then the
recursive calls in Step 4 takes time at most T (n=2; k0) + T (n=2; k00), where
k0 + k00 = k, since it is easy to see that S 0 SL and S 00 SR . Therefore, we
have the following recurrence relation.
T (n; k) = T (n=2; k0) + T (n=2; k00) + O(n)
POINT LOCATION 89
We can prove by induction on k that T (n; k) = O(n log k). The detailed
proof is left to the reader.
Thus KIRKPATRICK-SEIDEL algorithm runs in time O(n log k). When
k is small, KIRKPATRICK-SEIDEL algorithm is not worse than Jarvis'
March that has the time complexity O(kn) (even better), and when k is
large, it is still not worse than Graham Scan, since k is always less than or
equal to n. However, KIRKPATRICK-SEIDEL algorithm has very nasty
constants because the algorithm to nd the median is hard to program. So,
in the real world, people use Graham Scan.
Finally, we brie y discuss the dierence between MERGEHULL,
QUICKHULL and KIRKPATRICK-SEIDEL algorithm. KIRKPATRICK-
SEIDEL algorithm has the advantages in both MERGEHULL and QUICK-
HULL. It divides the given set evenly, like MERGEHULL, and merges partial
hulls eciently, like QUICKHULL. The time complexity of MERGEHULL
has a factor log n instead of log k because in the two recursive calls, many
points that are in the convex hulls of the two subsets but not in the convex
hull of the original set are introduced. In QUICKHULL, the median point of
the given set S may unfortunately be not a hull vertex, therefore algorithm
would not work if we simply replace the furthest point in the algorithm by
the median point.
6.2 Point location problems

In the remaining of this chapter, we discuss the point location problems.
We rst present a simple algorithm, the slab method, which runs in O(n2 )
preprocessing time, O(n2) storage, and O(log n) query time, where the ge-
ometric sweeping technique is used in the preprocessing. Then we give an
optimal algorithm for the point location problem, Kirkpatrick's algorithm,
which runs in O(n) preprocessing time, O(n) storage, and O(log n) query
time for connected PSLGs, where the renement method, which is a variety
of prune and search technique, is used.
6.2.1 Complexity measures and a simple example
Suppose that we have a PSLG G, and we want to know in which region of
G a given query point is located. In the simplest case, we have only one
query point. Then we can search the point in each region of G directly to
nd the region containing the point. A one-time query of this type is called
single shot. However, we may have many query points and want to nd the
90 PRUNE AND SEARCH
containing region for each query point. Such queries are called repetitive-
mode queries.
In the case of repetitive-mode queries, it may be worthwhile to arrange
the PSLG G into a more organized structure to facilitate searching. There-
fore, when we are considering the problem of repetitive-mode queries, we are
interested in three computational resources: the preprocessing time that is
used to convert the given PSLG into an organized structure, the storage that
is used to store the organized structure, and the query time that is needed
to locate each query point.
Suppose that the input PSLG G has n vertices. In general, we cannot
expect that the preprocessing time is less than O(n) since even reading
the input PSLG G takes time
(n). Similarly, we cannot expect that the
storage used for the organized structure is less than O(n) since even storing
the unorganized structure, the PSLG G itself needs
(n) space. Finally,
as pointed out by Knuth [14], any algorithm for searching an ordered table
of length n by means of comparisons can be represented as a binary tree
of n leaves, thus in the worst case, the searching time is at least
(log n).
While the point location problem is clearly a generalization of searching,
we conclude that the query time of the point location problem is at least
(log n).
Let us consider a simple example. Suppose that the PSLG G is a convex
polygon P of n vertices. So the vertices of P are given in, say, counter-
clockwise ordering fv1; v2; ; vn g. We rst organize P by the following
algorithm:
Algorithm PREPROCESSING (P)
Given: a convex polygon P
Output: an organized structure L for P
BEGIN
1. Find an internal point p_0 of P;
2. For each edge {v_i, v_(i+1)} of P, i = 1, ..., n,
(where we let v_(n+1) = v_1) construct the wedge
W_i formed by the ray started at the point p_0
and passing through v_i (call it the starting ray
of the wedge W_i) and the ray started at p_0 and
passing through v_(i+1) (call it the ending ray
of the wedge W_i);
3. Sort the wedges { W_i | 1 <= i <= n } by the slopes
of their starting ray. Let the sorted list be L;
4. Attach the edge {v_i, v_(i+1)} to the element of L
POINT LOCATION 91
corresponding to the wedge W_i, for i = 1, ..., n;
END.
With the list L, we can locate each query point by the following algo-
rithm.
Algorithm QUERY (q)
Given: a query point q and the organized structure

L of P
Output: an answer to "the point q is inside P?"
BEGIN
1. Compute the slope of the ray started at p_0 and
passing through q;
2. Using binary search on the list L to locate the
point q in a wedge W_i;
3. The point q is inside the convex polygon P if and
only if the point q is inside the triangle formed
by the wedge W_i and the edge {v_i, v_(i+1)};
END.
Now we analyze the above algorithms.

Preprocessing time
The preprocessing is implemented by the algorithm PREPROCESSING.
The internal point p0 of P can be found by, for example, computing the cen-
troid of the triangle determined by any three vertices of the convex polygon
P . Thus Step 1 takes constant time. Step 2 takes time O(n) because given
two points, the equation of the ray passing through them can be constructed
in constant time. To consider Step 3, we suppose, without loss of generality,
that the slope of the starting ray of the wedge W1 is 0 (otherwise, we rotate
the system to make this). Then the wedges, sorted by their starting rays,
are exactly in the order W1, W2 , , Wn . Since we can read the edges of P
in counterclockwise ordering, the wedges can be read exactly in the sorted
ordering. Therefore, Step 3 to construct the list L, together with Step 4
to attach edges to the list L, takes time O(n). We conclude that the total
preprocessing time is O(n)
Storage
92 PRUNE AND SEARCH
Since the equation of each ray is a linear equation of two variables, which
can be represented in constant space, each element of the list L takes constant
space. Consequently, the list L takes O(n) space.
Query time
Locating each query point is implemented by the algorithm QUERY (q).
It is easy to see that Step 1 in the algorithm takes constant time, while
Step 2 in the algorithm takes O(log n) time. Finally, knowing the two rays
forming the wedge Wi and the edge fvi ; vi+1g, we can determine in constant
time if the query point is inside the triangle formed by the wedge and the
edge.
We conclude with the following theorem.
Theorem 6.2.1 Point location problem on convex polygons can be solved
with O(n) preprocessing time, O(n) storage, and O(log n) query time.
6.2.2 Slab method

Now we consider the point location problem on general PSLGs. Let G be
a PSLG with n vertices. Through each vertex of G, we draw a horizontal
line. The plane is subdivided by these horizontal lines into \slabs". Since
G is a PSLG, there is no edge-crossing in G and since we have drawn a
horizontal line through each vertex of G, in the interior of each slab, there
is neither edge intersection nor vertex of G. Therefore, the edge segments
of G contained in a slab can be ordered from left to right. If we construct
a list of edge segments, ordered from left to right, for each slab, then the
algorithm for locating a query point will look as follows, where L is a list
of slabs, sorted by y -coordinate (that is, any point in slab L[j ] has a larger
y-coordinate than a point in slab L[i] for i < j ). Each element L[i] in the
list L also has a pointer to a list li of edge segments in the corresponding
slab, ordered from left to right.
Algorithm LOCATING (p_0)
Given: a query point p_0, and a PSLG G represented

by a list L of slabs. Each slab L[i] is
associated with a list l_i of edge segments
in the slab ordered from left to right
Output: a region of G that contains the point p_0
POINT LOCATION 93
BEGIN
1. Using the y-coordinate y_0 of the point p_0,
we perform binary search in the list L to find
a slab L[i] that contains the point p_0;
2. Using the x-coordinate x_0 of the point p_0,
we perform binary search in the list l_i to
find a pair of edge segments e_1 and e_2 such
that the point p_0 is between these two edge
segments;
END.
There are exactly n vertices of G, therefore, the binary search in Step 1

of the algorithm can be done in time O(log n). Moreover, since G is a planar
graph it has O(n) edges. Each edge of G can contribute at most one edge
segment to a slab. Thus each slab contains O(n) edge segments. Therefore,
the binary search in Step 2 of the algorithm can also be done in time O(log n).
Two consecutive edge segments in a slab correspond to a unique region of
the PSLG G. So if we attach the region name to each pair of consecutive
edge segments in each slab, then after Step 2 of the above algorithm, we can
read directly the name of the region that contains the point p0 . We conclude
that the query time of this slab method is O(log n).
Now we discuss how we produce and store the sorted list L and the sorted
lists li . As the analysis given above, each list li contains at most O(n) edge
segments, thus the space we used to store the lists L and li 's is bounded by
O(n2 ). This storage cannot be improved since some PSLG does have the
structure such that there are
(n2 ) edge segments in the slabs. Figure 6.1
gives an example of such a PSLG.
A straightforward method to produce these lists is to sort the vertices of
G by y-coordinate rst to get the sorted list L of the slabs, then for each slab
L[i], sort the edge segments in the slab to get the sorted list li. Then the
time complexity to obtain the list L is O(n log n), and the time complexity to
obtain all the lists li, i = 1; 2; ; n+1 will be O((n+1)n log n) = O(n2 log n).
Can we do better?
Again we exploit the idea of geometric sweeping. We maintain the edge
segments of a slab in a 2-3 tree and let the edge segments be ordered from
left to right in the tree. When we move up from one slab to another slab, we
look at those vertices on the boundary of the two slabs. We delete the lower
edges and insert the upper edges for these vertices. The resulting 2-3 tree
94 PRUNE AND SEARCH
Figure 6.1: A PSLG containing

(n2 ) edge segments
then represents exactly the list of the edge segments, ordered from left to
right, of the next slab. We print the leaves of each 2-3 tree, from left to right,
and obtain the lists li for i = 1; ; n + 1. The following is the algorithm
of the preprocessing of the slab method. For simplicity, we assume that no
two vertices of the PSLG G have the same y -coordinate. If this condition
is not satised, we either rotate the coordinate system slightly, or make a
straightforward modication on the algorithm.
Algorithm PREPROCESS (G)
Given: a PSLG G, represented by a DCEL

Output: the lists L and l_i for i = 1, ..., n+1
BEGIN
1. Sort the vertices of G by increasing y-coordinate.
Let the sorted list of the vertices of G be
{ v_1, v_2, ..., v_n }
Then construct the list L;
(each slab L[i] of L, i = 1, ..., n+1, is
POINT LOCATION 95
associated with two vertices v_{i-1} and v_i
of G, one is on the lower boundary and the other
is on the upper boundary of the slab, where v_0
has a very large negative y-coordinate while v_(n+1)
has a very large positive y-coordinate.)
2. For slab L[1], construct an empty 2-3 tree T_1.
The list l_1 for the slab L[1] is also empty;
Set k = 2;
3. Look at the vertex v_(k-1), delete all lower edges
of the vertex v_(k-1) from the tree T_(k-1) and
insert all upper edges of the vertex v_(k-1) into
the tree T_(k-1). The resulting tree T_k is the
2-3 tree for the slab L[k].
4. Read the leaves of the 2-3 tree T_k, from left
to right, and produce the list l_k;
5. If k <= n then k = k + 1 and go back to Step 3;
END.
It is obvious that the above algorithm is correct. Now we analyze the

algorithm. Step 1 takes time O(n log n) by using any optimal sorting algo-
rithm. Consider the loop of Step 3 - Step 5. Since each slab contains at
most O(n) edge segments, all 2-3 trees Tk , k = 1; ; n + 1, have size O(n).
Consequently, the depth of each 2-3 tree Tk is bounded by O(log n). There-
fore, each edge insertion and edge deletion can be done in time O(log n).
Each edge of G is inserted exactly once into some 2-3 tree Tk then deleted
exactly once from some other 2-3 tree Tk0 . Moreover, given the vertex vk?1 ,
all the edges of G incident to vk?1 can be found by an algorithm called
TRACE-VERTEX, which is similar to the algorithm TRACE-REGION in
Section 1.4, in time proportional to the number of these edges (we suppose
that the PSLG G is represented by a DCEL). Thus each of the lower edges
and upper edges of vk?1 in Step 3 can be found in constant time. Therefore,
the time of insertion and deletion of an edge of the PSLG G is bounded by
O(log n) for the whole algorithm. Consequently, the total time of the algo-
rithm taken by Step 3 is bounded by O(n log n) since G contains O(n) edges.
Now to read the leaves of the 2-3 tree Tk from left to right, we can use, say,
depth rst search on the tree Tk . (For the discussion of depth rst search of
a graph, see [2].) The time to read the tree Tk and then to produce the list
lk thus is bounded by some constant times the number of nodes in the tree
Tk , which is bounded by O(n). Therefore, the total time of the algorithm
taken by Step 4 is bounded by O(n2 ). This cannot be improved as we have
96 PRUNE AND SEARCH
seen, some PSLG contain
(n2 ) many edge segments.
Thus the time complexity of the algorithm PREPROCESS is bounded
by
O(n log n) + O(n log n) + O(n2 ) = O(n2)
We conclude with the following theorem.
Theorem 6.2.2 Using the slab method solving the point location problem,
the preprocessing time is O(n2 ), the storage is O(n2 ), and the query time is
O(log n).
6.2.3 Renement method I: on rectangles

The renement method for point location problem is a variety of the prune
and search technique. To motivate the renement method for the point
location problem, we rst consider a class of simple PSLGs.
Let X = (x1 ; x2; ; xm) and Y = (y1 ; y2; ; ym ) be two lists of m real
numbers sorted in increasing order. Dene a PSLG G as follows: G has
n = m2 vertices vi;j = (xi; yj ), i; j = 1; 2; ; m. For 2 i; j m ? 1,
the vertex vi;j is adjacent to exactly four vertices vi;j ?1 , vi;j +1 , vi?1;j and
vi+1;j . The vertex v1;j (resp. vn;j ) for 2 j m ? 1 is adjacent to the
vertices v1;j ?1 , v1;j +1 and v2;j (resp. vn;j ?1 , vn;j +1 , and vn?1;j ). The vertex
vi;1 (resp. vi;n) for 2 i m ? 1 is adjacent to the vertices vi?1;1, vi+1;1
and vi;2 (resp. vi?1;n , vi+1;n , and vi;n?1 ). Finally, the vertex v1;1 is adjacent
to v1;2 and v2;1, the vertex v1;n is adjacent to v1;n?1 and v2;n , the vertex vn;1
is adjacent to vn;2 and vn?1;1 , and the vertex vn;n is adjacent to vn?1;n and
vn;n?1 . Call the whole PSLG an m m rectangle with the index sets X and
Y . Figure 6.2 pictures a 5 5 rectangle.
Clearly, the point location problem on this kind of PSLGs can be simply
done by doing two binary searchings, one on the list X and the other on the
list Y . Alternatively, we can also locate a query point p0 = (x0; y0) in the
following way: compare the value x0 with the middle number xm=2 in the
list X and determine that the point p0 is in the left rectangle Rl bounded
by the vertices v1;1 , vm=2;1, vm=2;m and v1;m or in the right rectangle Rr
bounded by the vertices vm=2;1, vm;1 , vm;m and vm=2;m . Suppose that p0
is in the left rectangle Rl . Now we compare the value y0 with the middle
number ym=2 in the list Y to determine that the point p0 is in the upper
rectangle Rl;u bounded by the vertices v1;m=2, vm=2;m=2, vm=2;m and v1;m or
in the lower rectangle Rl;l bounded by the vertices v1;1, vm=2;1, vm=2;m=2 and
POINT LOCATION 97
y5
y4
y3
v3,3
y2
y1
x1 x2 x3 x4 x5
Figure 6.2: A 5 5 rectangle with the center vertex v3;3
v1;m=2. Thus two comparisons restrict the point p0 to an (m=2) (m=2)

subrectangle. Now we recursively work on the (m=2) (m=2) rectangle.
Let Rm be an m m rectangle with index sets
X = (x1; ; xm) and Y = (y1 ; ; ym)
A vertex vi;j is the center vertex of Rm if i = j = m0 = dm=2e. Note that
to determine which (m=2) (m=2) subrectangle a query point p0 is in, we
only need two values from the index sets: the middle number xm0 in the
list X and the middle number ym0 in the list Y . But (xm0 ; ym0 ) is just the
coordinates of the center vertex vm0 ;m0 of the rectangle Rm . Therefore, the
m m rectangle Rm can be organized in the following way: construct a tree
Tm whose root N0 is attached with the center vertex vm0;m0 of Tm. There
are four children of the root N0 , corresponding to the four (m=2) (m=2)
subrectangles of Rm obtained by dividing Rm by a horizontal line and a
vertical line passing through the center vertex vm0 ;m0 . The algorithm of
constructing this tree is presented as follows:
Algorithm CONSTRUCTING-TREE(R_m)
Given: a PSLG R_m that is an m by m rectangle

Output: a hierarchy tree T_m
BEGIN
1. If R_m is a 2 by 2 rectangle, then R_m is a
98 PRUNE AND SEARCH
single region. Create a tree node for R_m
and attach the name of the region to the
node; STOP.
2. { R_m is not a single region. }
Create a node N_m for R_m, attach the center
vertex v_(m_0,m_0) of R_m to N_m. Draw a
horizontal line and a vertical line passing
through the center vertex v_(m_0,m_0) that divides
the rectangle R_m into four (m/2) by (m/2)
subrectangles;
3. Recursively call the algorithm CONSTRUCTING-TREE
on the four (m/2) by (m/2) subrectangles. Let
the resulting four trees be T_1, T_2, T_3, and
T_4;
4. Let T_1, T_2, T_3 and T_4 be the children of the
node N_m;
END.
Each leaf in the tree Tm corresponds uniquely to a region of the rectangle

Rm, and each internal node of the tree Tm corresponds to a vertex of Rm.
Since there are n = m2 vertices and O(n) regions in the rectangle Rm , we
conclude that the number of nodes of the tree Tm is bounded by O(n).
Moreover, since we spend constant time to create a node in the tree Tm, the
total time of constructing the tree Tm is bounded by O(n).
Since the tree Tm is very balanced: each internal node of Tm has exactly
four children, and since the tree Tm has O(n) nodes, we conclude that the
depth of the tree Tm is bounded by O(log n).
This is the preprocessing for the point location problem on rectangles.
Given a query point p0, it is easy to locate p0 in an m m rectangle Rm
with the help of the tree Tm, as shown by the following algorithm.
Given: a query point p_0 and the hierarchy

tree T_m
Output: the region that contains the point p_0
BEGIN
1. First use the four corner vertices v_(1,1),
v_(m,1), v_(m,m) and v_(1,m) to determine
POINT LOCATION 99
if p_0 is contained in the rectangle R_m.
If p_0 is out R_m, report so and STOP.
2. { p_0 is inside R_m. }
Starting by the root N_0 of the tree T_m,
compare p_0 with the center point of R_m
to find a child of N_0 that corresponds to
an (m/2) by (m/2) rectangle R_(m/2) containing
the point p_0;
3. Recursively search p_0 in the rectangle R_(m/2);
END.
It is clear that the algorithm LOCATING runs in time O(log n) for each
query point p0 .
Therefore, the point location problem on rectangles can be solved by
O(n) preprocessing time, O(n) storage, and O(log n) query time.
Let us summarize the above idea: We rst locate the query point into a
large m m rectangle Rm , then we rene the rectangle Rm into four smaller
(m=2) (m=2) rectangles by dividing the rectangle Rm by a horizontal line
and a vertical line passing through the center vertex of Rm, then we recur-
sively locate the point p0 in one of these smaller rectangles.
Two properties we have used heavily in this method:
A father and its children have the same geometric shape (here are
rectangles), so the recursive call is eective.
Each father has only constant many children so that in constant time
we can move one level down in the search tree Tm .
6.2.4 Renement method II: on general PSLGs
Now we try to extend the idea in the last section to solve the point location
problem on general PSLGs. The algorithm discussed in this section is due
to Kirkpatrick [12].
All the geometric objects in the renement method on rectangles are
simple rectangles. Moreover, it is easy to rene a rectangle into four smaller
rectangles by a horizontal line and a vertical line. However, in a general
PSLG, a region can be an arbitrary simple polygon, and it is not guaranteed
that a simple polygon can be rened into smaller polygons of the same
shape. Therefore, we must rst x a geometric shape we are going to use. It
is natural to consider the simplest geometric shape, the triangles. However,
100 PRUNE AND SEARCH
not every PSLG can be obtained by rening a triangle. Extra care should
be taken to make our idea work.
A PSLG G is completely triangulated if G is connected and the boundary
of every region of G (including the unbounded region) is a triangle. We
rst discuss how to convert a general PSLG into a completely triangulated
PSLG.
Given a general PSLG G which is not completely triangulated. We rst
add a big triangle 4 that encloses the whole G. This can be done by rst
scanning the vertices of G to nd the minimum x0 of the x-coordinates of
the vertices of G, the minimum y0 of the y -coordinates of the vertices of G,
and the maximum z0 of the values x + y where (x; y ) is a vertex of G. Now
the triangle formed by the horizontal line lh : y = y0 ? 1, the vertical line
lv : x = x0 ? 1, and the line l : x + y = z0 + 1 will enclose the whole PSLG
G. Let the PSLG consisting of G and 4 be G0. Now triangulating G0 gives
us a completely triangulated PSLG G0 .
Delete an internal vertex v from G0 and let the resulting PSLG be G00 . If
the vertex v has degree k in the PSLG G0 , then G00 has all its regions being
triangles except one region that is a k-gon Pk . To make G00 have the same
geometric property as G0 , we retriangulate the k-gon Pk of G00 . Of course,
we can perform the above operation on other vertices of G0 as well provided
that the vertices we delete are not adjacent to each other in G0. Let G1 be
the new completely triangulated PSLG obtained by this kind of deleting-
vertex-then-retriangulating operation on a set of non-adjacent vertices of
G0 . All regions of G0 are regions of G1 except those that disappear when we
delete the vertices of G0 (call these regions old triangles). All regions of G1
are regions of G0 except those that are created when we retriangulate the
non-triangle regions resulting from deleting vertices in G0 (call these regions
new triangles). We set a pointer from a new triangle to an old triangle if their
intersection is not empty. Note that the new PSLG G1 has less vertices than
the old PSLG G0. The old PSLG G0 thus can be regarded as a renement
of the new PSLG G1 .
This solves our rst problem: the inverse of the deleting-vertex-then-
retriangulating operation renes a completely triangulated PSLG G1 into
a larger completely triangulated PSLG G0 (here \larger" means containing
more vertices and more regions. In this sense, the regions of G0 are \smaller"
than that of G1).
The query algorithm now goes as follows: suppose that we have located
a query point p0 in a new triangle 4, then we look at all old triangles that
intersect the new triangle 4 and determine which old triangle contains the
POINT LOCATION 101
query point p0 .
However, how many old triangles intersect the new triangle 4? And
how many completely triangulated PSLGs should we go through in order
to locate the query point p0 in a triangle of the original PSLG? In order to
achieve an O(log n) query time, we must move from one completely trian-
gulated PSLG to another completely triangulated PSLG in constant time,
and go through at most O(log n) completely triangulated PSLGs to reach
the original completely triangulated PSLG. For this purpose, we require that
the vertices to be deleted from one completely triangulated PSLG in order
to construct the next PSLG satisfy the following conditions:
1. All these vertices should be internal vertices, that is, they are not the
three hull vertices of the completely triangulated PSLG.
2. No two of these vertices are adjacent.
3. The degree of these vertices is small.
4. There are enough vertices of the current completely triangulated PSLG
to be deleted.
The rst condition makes all our PSLGs completely triangulated. The
second condition ensures that the relationship between new triangles and old
triangles simple, that is, an old triangle incident to a deleted vertex v can
only intersect those new triangles that are obtained by retriangulating the
simple polygon resulting from deleting the vertex v from G0 . The second
and the third conditions together ensure that each old triangle intersects very
few new triangles, and each new triangle intersects very few old triangles.
Finally, the fourth condition ensures that the rate of the size-shrinking of the
completely triangulated PSLGs is fast so that a query point goes through
very few completely triangulated PSLGs to reach the original PSLG.
The existence of a set of vertices of a completely triangulated PSLG that
satises all conditions above is proved by a pure combinatorial counting
technique.
Let G be a completely triangulated PSLG. Suppose that the set of ver-
tices, the set of edges, and the set of regions of G are V , E , and F , respec-
tively. Since G is a planar imbedding, by Euler's formula:
jV j ? jE j + jF j = 2
Since G is a completely triangulated PSLG, each region of G has exactly 3
boundary edges. On the other hand, each edge of G is a boundary edge for
exactly two regions. This gives us
3jF j = 2jE j
Replacing jF j in Euler's formula by 32 jE j, we obtain
jE j = 3jV j ? 6 < 3jV j
Let deg (v ) be the degree of the vertex v , then each vertex v of G incident
to exactly deg (v ) edge-ends. On the other hand, each edge has exactly two
edge-ends, thus we have
X
deg(v) = 2jE j < 6jV j
v is a vertex of G
Therefore, at least half of the vertices of G have degree less than 12. If we
exclude the three hull vertices of G, then there are at least jV j=2 ? 3 vertices
of G that have degree less than 12. For each vertex of degree less than 12,
there are at most 11 adjacent vertices, thus there are at least (jV j=2 ? 3)=12
vertices of degree less than 12 in G such that no two of them are adjacent.
When jV j 48, we have (jV j=2 ? 3)=12 jV j=48. Therefore, for an arbitrary
completely triangulated PSLG G with n vertices, with n 48, we can nd
at least n=48 internal non-adjacent vertices of G of degree less than 12.
This analysis gives us the following algorithm to construct a searching
hierarchy TG .
Algorithm CONSTRUCT-HIERARCHY(G)
Given: a general PSLG G

Output: a searching hierarchy T_G for the
point location problem on G
BEGIN
1. Add an enclosing triangle that contains the whole
G, then triangulate the resulting PSLG. Let the
completely triangulated PSLG be G_0;
2. Using the TRACE-REGION algorithm in Section 1.4 to
find all triangles of G_0. For each triangle of
G_0, create a node in level 0 in the hierarchy T_G;
3. Set k = 0;
4. Suppose that the PSLG G_k contains n_k vertices.
Find at least (n_k)/48 internal non-adjacent
POINT LOCATION 103
vertices of G_k that have degree less than 12;
5. For each vertex v found in Step 4, delete v from
G_k, and retriangulate the simple polygon resulting
from this deletion. For each new triangle obtained
from this retriangulation, create a node in level
k+1 of the hierarchy T_G and set a pointer from
this node in the hierarchy T_G to a node corres-
ponding to an old triangle incident to the vertex
v in G_k if the intersection of the old triangle
and the new triangle is not empty.
6. Let the resulting completely triangulated PSLG be
G_(k+1), then set k = k + 1. If the PSLG has
more than 48 vertices, go back to Step 4.
END.
We analyze the algorithm of constructing the hierarchy. Suppose that the

number of vertices of G0 is n, which is three more than that of the original
PSLG G, and that each completely triangulated PSLG Gk is represented
by a doubly-connected edge list (DCEL). As we discussed before, It takes
O(n) time to construct an enclosing triangle. Then the triangulation takes
time O(n log n) if the PSLG is a general PSLG, or takes time O(n) if the
PSLG is connected (triangulating a connected PSLG in linear time is a recent
breakthrough due to Chazelle [8]). Therefore, Step 1 of the algorithm takes
time O(n log n) for a general PSLG G and takes time O(n) for a connected
PSLG G.
The TRACE-REGION algorithm takes time O(n) to nd all regions,
therefore, Step 2 of the algorithm takes time O(n).
By the analysis given above, each PSLG Gk contains at least nk =48
internal non-adjacent vertices of degree less than 12. To nd these vertices of
Gk , we simply scan the DCEL for Gk (using a TRACE-VERTEX algorithm
that is similar to the algorithm TRACE-REGION), whenever we nd a
vertex v of degree less than 12, we take v and mark all vertices adjacent to v
\unusable". We scan the list of vertices of Gk and ignore those \unusable"
vertices. In this way, by the analysis we gave above, we can nd at least
nk =48 internal non-adjacent vertices of degree less than 12. In this process,
we scan each vertex of Gk at most once and scan each edge of Gk at most
twice. Therefore, Step 4 of the algorithm takes time O(nk ) for the PSLG
Gk .
For each vertex v found in Step 4, since the degree of v is less than 12,
there are at most 11 triangles incident to v . Moreover, deleting v results in
a simple polygon of at most 11 vertices since v has degree less than 12, so at
most 9 new triangles are created when we retriangulate the simple polygon.
Consequently, each new triangle intersects at most 11 old triangles and each
old triangle intersects at most 9 new triangles. Therefore, each node of a new
triangle has at most 11 pointers to nodes of old triangles, and a node for a
new triangle together with its pointers to the old triangles can be created in
constant time. So to produce the level k + 1 in the hierarchy TG takes time
proportional to the number of regions in the PSLG Gk+1 , which is bounded
by O(nk+1 ) where nk+1 is the number of vertices of Gk+1 . It is also easy to
see that constructing the DCEL for the PSLG Gk+1 from the DCEL for the
PSLG Gk also takes time O(nk+1 ).
Therefore, the total time used in Step 4 - Step 6 to build up the hierarchy
TG is bounded by
O(n0 ) + O(n1) + + O(nh ) = O(n0 + n1 + + nh )
if the hierarchy TG has h + 1 levels.
n0 = n. Since G1 is obtained from G0 by deleting at least n0 =48 vertices,
so we have n1 (47=48)n. A simple induction proves that nk (47=48)k n
for all k 1. Therefore,
O(n0 + n1 + + nh )
O(n + (47=48)n + + (47=48)hn)
< O(n + (47=48)n + + (47=48)h n + )
= O( 1?(47n =48) )
= O(n)
That is, the total time to build up the hierarchy TG for the completely
triangulated PSLG G0 is bounded by O(n). Consequently, the hierarchy TG
contains O(n) nodes thus can be stored in space O(n).
Now the searching algorithm for a query point in the hierarchy TG is
straightforward.
Given: a query point p_0 and the hierarchy structure

T_G for a PSLG G
Output: the region of G that contains the point p_0
BEGIN
EXERCISES 105
1. In the highest level of the hierarchy T_G, locate
the point p_0 into one of the triangles;
2. Suppose p_0 is in a node N_0 of the hierarchy T_G.
Check each triangle whose node in the hierarchy
T_G is pointed by a pointer from N_0 to find a
node N' whose triangle contains the point p_0;
3. IF N' is at level 0, then we have located the
point p_0 into a triangle in the original PSLG.
ELSE let N_0 = N' and go back to Step 2;
END.
Since a point p0 is contained in a new triangle after the retriangulation

if and only if it is contained in some old triangle before the vertex deletion,
the point p0 is contained in the triangle corresponding to the node N0 if
and only if it is contained in a triangle whose corresponding node in the
hierarchy TG is pointed by a pointer from N0. Therefore, the above algorithm
LOCATING(p0 ) correctly nds a triangle in the original PSLG that contains
the point p0 . Since each pointer in the hierarchy TG is always from a higher
level to a lower level and each node in the hierarchy has at most 11 pointers,
the searching time of the algorithm LOCATING is proportional to the depth
of the hierarchy TG . Let nk be the number of vertices of the PSLG Gk , for
k = 0; 1; , then as analyzed above, we have nk (47=47)k n, and we stop
producing more levels when we reach nk 48. This gives us immediately
The number of levels in the hierarchy TG = O(log n)
We summarize the above results in the following theorems.
Theorem 6.2.3 For a general PSLG G, the point location problem can be
solved with O(n log n) preprocessing time, O(n) space, and O(log n) query
time.
Theorem 6.2.4 For a connected PSLG G, the point location problem can
be solved with O(n) preprocessing time, O(n) space, and O(log n) query time.
6.3 Exercises
1. Based on the idea described in the text, design a linear time algorithm
that nds the median given a set of numbers.
2. Design an algorithm to solve the following problem: given a set S of
N points in the plane, with preprocessing, decide for a query point
if the point is in a triangle whose three vertices are points of S . If
it is, output the three vertices of the triangle (if there are more than
one such triangles, pick any one of them). Analyze your algorithm for
query time, preprocessing time, and space.
3. Solve the Point Location Problem for the set of PSLGs whose faces are
of size at most 5. What are the query time, preprocessing time and
space of your algorithm?
4. Given a PSLG G such that the number of intersection points of any
vertical line and G is bounded by 50. Moreover, a sorted list of the
vertices of the PSLG G is also given. Discuss the preprocessing time,
space, and query time of the point location problem on G.
5. A k-monotone polygon with respect to a line l is a simple polygon which
can be decomposed inot k chains monotone with respect to the line l.
Let k be a xed constant. Design an algorithm to solve Point Location
Problem for k-monotone polygons, i.e., given a k-monotone polygon
P , with preprocessing, determine if a query point is internal to P .
Analyze your algorithm for query time, preprocessing time and space.
6. Given two sets of points Sp = fp1 ; ; pn g and Sq = fq1 ; ; qmg. For
each point in Sq , nd the closest point in Sp . Solve this problem for
the case
(1). m is much larger than n, say m = 2n ;
(2). m is much smaller than n, say m = log log n.
Do you use the same algorithm to solve the problem for both cases or
you use dierent algorithms for the two cases? Give a detailed analysis
for yours algorithm(s).
7. A point p is said to be dominated by a point q if both x- and y -
coordinates of p are no greater than those of q , respectively. Solve
the following problem: given a set S of n points in the plane, with
preprocessing allowed, for each query point q , nd the number of points
in S dominated by q . That are the preprocessing time, storage, and
query time of your algorithm?
EXERCISES 107
8. Suppose that we can construct the kth order Voronoi diagram in time
O(k2N log N ). Analyze the query time, preprocessing time, and the
storage for the k-Nearest Points Problem.
9. Let p1 = (x1 ; y1) and p2 = (x2; y2) be two points in the plane. We say
that point p1 dominates point p2 if x1 x2 and y1 y2 .
Let S be a set of points in the plane. A point p 2 S is a maximal
element if p is not dominated by any other point in S .
Solve the following problem:
Given a set of n points in the plane, let k denote the number of maximal
elements in this set. Design a divide-and-conquer algorithm of time
O(n log k) for nding these maximal elements. Prove the correctness
of your algorithm.
Chapter 7
Reductions
Let P and P 0 be two problems. We say that the problem P can be reduced
to the problem P 0 in time O(t(n)), express it as
P /t(n) P 0
if there is an algorithm T solving the problem P in the following way.
1. For any input x of size n to the problem P , convert x in time O(t(n))
into an input x0 to the problem P 0 ;
2. Call a subroutine to solve the problem P 0 on input x0;
3. Convert in time O(t(n)) the solution to the problem P 0 on input x0
into a solution to the problem P on input x.
Note that the subroutine in Step 2 that solves the problem P 0 is unspec-
ied. If the problem P 0 can be solved eciently, then the problem P can
also be solved eciently, as explained by the following theorem.
Lemma 7.0.1 Suppose that a problem P is reduced to a problem P 0 in time
O(t(n))
P /t(n) P 0
and that the problem P 0 can be solved in time O(T (n)). Then the problem
P can be solved in time O(t(n) + T (O(t(n)))).
proof. Suppose that the algorithm T gives a O(t(n))-time reduction
from the problem P to the problem P 0 , and suppose that an algorithm A0
109
110 REDUCTIONS
solves the problem P 0 in time O(T (n)). The problem P can be solved by
the algorithm T , in whose Step 2, calling a subroutine to solve the problem
P 0 on input x0, we use the algorithm A0 .
To analyze the algorithm T , note that Step 1 and Step 3 of the algo-
rithm T take time O(t(n)), as we have assumed. Since Step 1 takes time
O(t(n)), the size of x0 is also bounded by O(t(n)). Therefore, in Step 2 of
the algorithm T , the algorithm A0 of time complexity O(T (n)) on inputs of
size n takes time O(T (O(t(n)))) on input x0 , which is of size O(t(n)). This
concludes that the running time of the algorithm T is bounded by
O(t(n)) + O(T (O(t(n)))) = O(t(n) + T (O(t(n))))
The reduction technique plays an important role in the study of complex-

ity of geometric problems, both for deriving lower bounds and for designing
ecient algorithms. In this chapter, we will study how to use this tech-
nique to design ecient geometric algorithms, and in the next chapter, we
will explain how we use this technique to derive lower bounds for geometric
problems.
We close this introductory section by the following corollary, which will
be heavily used in our discussion.
Corollary 7.0.2 Suppose that a problem P is reduced to a problem P 0 in
linear time
P /n P 0
If the problem P 0 can be solved by an algorithm in time O(T (n)), with T (n) =
(n) and T (O(n)) = O(T (n)), then the problem P can also be solved in time
O(T (n)).
proof. As shown in Lemma 7.0.1, the problem P can be solved by
the algorithm T in time O(n + T (O(n))). By our assumption, T (O(n)) =
O(T (n)). Moreover, T (n) =
(n). Therefore, the time complexity of the
algorithm T in this special case is bounded by
O(n + O(T (n))) = O(T (n))
Notice that most of the complexity functions T (n) we use in this book,
such as n, n log n, nk , and nk logh n satisfy the conditions T (n) =
(n) and
T (O(n)) = O(T (n)).
7.1. CONVEX HULL AND SORTING 111
7.1 Convex hull and sorting
Consider the algorithm of Graham Scan for constructing convex hulls of
points in the plane. If a given set S of n points in the plane is sorted by
x-coordinates, then the Graham Scan algorithm needs only linear time to
construct the convex hull for S . In fact, it is not hard to see that
CONVEX HULL /n SORTING
by the following argument. Given an instance of CONVEX HULL, which
is a set S of n points in the plane, we can simply regard S as an instance
of SORTING if we let the x-coordinate of a point p in S be the \key" of
the point p. Therefore, we can simply translates instances of the problem
CONVEX HULL to instances of the problem SORTING. Now the solution
of SORTING on input S is a list of the points in S which is sorted by the
x-coordinates. The generalized Graham Scan algorithm shows that with this
solution to the SORTING, the convex hull CH(S) of the set S , which is the
solution of CONVEX HULL on the input S , can be constructed in time
O(n).
It is interesting that we can prove that the problem SORTING can also
be reduced to the problem CONVEX HULL in linear time.
Theorem 7.1.1
SORTING /n CONVEX HULL
proof. Given a list L of n real numbers x1, x2, , xn , which is an instance

to the problem SORTING, we can suppose that all of them are non-negative
since otherwise, we rst scan the list and nd the \most negative" number
x, then add ?x to each given number to make all non-negative.
We rst scan the list to nd the largest number xmax. Now for each
number xi in the given list L, we convert xi into a point pi in the plane such
that the polar angle of pi is 2 xmaxxi and the distance between p and the
i
origin O is 1 (so the point pi is on the unit circle). Let S be the set of all
these n points p1, p2, , pn in the plane. The set S is an instance of the
problem CONVEX HULL. Note that the set S can be obtained from the list
L in time O(n), since all we do is to scan the list L at most twice, then for
each number xi , we spend constant time to obtain the corresponding point
pi .
112 REDUCTIONS
Since the unit circle itself is convex, the n points in the set S must be all
on the convex hull CH (S ). Therefore, when the solution CH (S ) is returned
back for the problem CONVEX HULL on the input S , we must get the hull
vertices of S in counterclockwise ordering. If we suppose that we start with
the point with the smallest polar angle, then the hull vertices must be given
in increasing ordering of their polar angles. But since the polar angle of a
point in the set S is proportional to the value of the corresponding number
in the list L, the list of the polar angles of the points times x2max given in
counterclockwise ordering on CH(S) gives the sorted list of the numbers of
the list L. Therefore, given the solution for the problem CONVEX HULL
on the input S , we can obtain the solution for the problem SORTING on
the input L, that is a sorted list of the n numbers of L, by rst nding the
point with the smallest polar angle, then scanning the convex hull CH(S) in
counterclockwise ordering and multiplying the polar angle of each point by
xmax . This can obviously done in linear time.
2
Let P and P 0 be two problems, and let t(n) be a function of n. If we
have both
P /t(n) P 0 and P 0 /t(n) P
then we say that the problems P and P 0 are equivalently complex up to a
t(n)-time reduction, and express as
P t(n) P 0
When two problems are equivalently complex up to a linear time reduc-
tion, then if one of them can be solved in time O(T (n)), where T (n) =
(t(n)) and T (O(n)) = O(T (n), then by Corollary 7.0.2, the other can also
be solved in time O(T (n)).
By the above discussions, we have already shown
SORTING n CONVEX HULL
In fact, construction of convex hulls for sets of points in the plane is
a generalization of sorting. In sorting n numbers, we are asked to nd the
ordering of a set of points in the real line, while in constructing a convex hull,
we are asked to nd the ordering of polar angles, relative to an interior point
of the convex hull, of the \extreme points". The dierence is that in sorting,
every given number will appear in the nal sorted list, while in constructing
a convex hull, we also have to make the decision whether a given point is a
non-extreme point, and if yes, exclude it from the nal output list. On the
CLOSEST-PAIR 113
other hand, as we have discussed in the section, sorting is not easier at all
than constructing convex hulls for points in the plane.
7.2 Closest pair and all nearest neighbor

According to the denition of the Voronoi diagram (a partition of the plane
into regions such that each region is the locus of points closer to a point of
the set S than to any other point of S ), it is not surprising that the problems
CLOSEST-PAIR and ALL-NEAREST-NEIGHBOR can be solved eciently
through the Voronoi diagram. Recall that the problem CLOSEST-PAIR is
to nd the closest pair in a set of n points in the plane, while the problem
ALL-NEAREST-NEIGHBOR is that given a set S of n points in the plane,
for each point of S , nd the nearest neighbor in S . Finally, let VORONOI-
DIAGRAM denote the problem of constructing the Voronoi diagram for a
given set of n points in the plane.
Theorem 7.2.1
ALL-NEAREST-NEIGHBOR /n VORONOI-DIAGRAM
proof. Suppose that a set S of n points in the plane is an input to the

problem ALL-NEAREST-NEIGHBOR, we pass the input S to VORONOI-
DIAGRAM directly. The solution of VORONOI-DIAGRAM on the input
S will be the Voronoi diagram Vor(S) of the set S . By Lemma 5.2.2, for
each point pi in the set S , the nearest neighbor of pi in S denes a non-
degenerate Voronoi edge for the Voronoi polygon Vi of pi . Therefore, by
tracing the boundary of the Voronoi polygon of each point in the set S , we
can nd the nearest point for each point in the set S . This is the solution
of the problem ALL-NEAREST-NEIGHBOR. Given the Voronoi diagram
Vor(S) of the set S , each Voronoi polygon can be traced by the algorithm
TRACE-REGION given in Section 1.4 in time proportional to the number
of edges on the boundary of the polygon. Since each Voronoi edge is on
the boundary of exactly two Voronoi polygons, the sum of boundary edges
of all Voronoi polygons in Vor(S) equals twice the number of edges in the
Voronoi diagram Vor(S). We conclude that tracing all Voronoi polygons
of the Voronoi diagram Vor(S), thus nding the nearest neighbor for each
point in the set S when the Voronoi diagram Vor(S) is given, takes time
proportional to the number of edges of Vor(S), that is of order O(n) since
the Voronoi diagram is a planar graph.
114 REDUCTIONS
Since the Voronoi diagram of a set of n points can be constructed in time
O(n log n) (Theorem 5.3.6), by Corollary 7.0.2, we obtain
Corollary 7.2.2 The problem ALL-NEAREST-NEIGHBOR can be solved
in time O(n log n).
It is easy to see that given a set S of n points in the plane, the solution
of the problem CLOSEST-PAIR can be obtained from the solution of the
problem ALL-NEAREST-NEIGHBORS in linear time, that is,
CLOSEST-PAIR /n ALL-NEAREST-NEIGHBOR
by simply computing the distance between each point and its nearest neigh-
bor, then taking the point that has the shortest distance to its nearest neigh-
bor. By Corollary 7.2.2, the problem ALL-NEAREST-NEIGHBOR can be
solved in time O(n log n). Therefore by Corollary 7.0.2, we have
Corollary 7.2.3 The problem CLOSEST-PAIR can be solved in time
O(n log n).
7.3 Triangulation
Given a Voronoi diagram Vor(S) for the set S of n points in the plane. We
draw a segment pi pj for each pair of points pi and pj that dene a Voronoi
edge in Vor(S). Let D(S ) be the collection of these segments, which is called
the straight-line dual of the Voronoi diagram Vor(S).
We prove that the straight-line dual D(S ) of the Voronoi diagram Vor(S)
is a triangulation of the set S . For this, we must show that the straight-line
dual D(S ) partitions the convex hull CH(S) of the set S into triangles such
that 1) no two triangles overlap in the interior, and 2) every point in
the convex hull CH(S) (more precisely, every point in the area bounded by
the convex hull CH(S)) must be contained in at least one such triangles.
Each Voronoi vertex v is incident to exactly three Voronoi edges e1 , e2 ,
and e3 , and exactly three Voronoi polygons V1, V2 , and V3 of three points
p1 , p2, and p3 in the set S . Each of the edges e1 , e2 , and e3 is dened by
a pair of the points p1, p2 , and p3 . Therefore, the segments p1 p2, p2 p3 , and
p3p1 are all in the straight-line dual D(S ) of Vor(S). Thus, each Voronoi
vertex v corresponds to a triangle 4p1p2 p3 in the straight-line dual D(S ).
Denote by 4(v ) the triangle 4p1p2 p3. On the other hand, since a Voronoi
TRIANGULATION 115
C(v) C(v')
q'
Figure 7.1: Two circumcircles intersect at q and q 0
edge is incident on two Voronoi vertices, each segment in the straight-line

dual D(S ) is a boundary edge of two such triangles 4(v ) and 4(v 0), where
v and v 0 are two Voronoi vertices in Vor(S).
Lemma 7.3.1 No two triangles 4(v) and 4(v0) overlap in the interior,
where v and v 0 are two dierent Voronoi vertices in Vor(S).
proof. Let 4(v ) and 4(v 0) be two arbitrary triangles in the straight-line
dual D(S ) of the Voronoi diagram Vor(S). Let C (v ) and C (v 0) be the cir-
cumcircles of the triangles 4(v ) and 4(v 0), respectively. If the circumcircles
C (v) and C (v 0) do not overlap in the interior, then of course the triangles
4(v) and 4(v0) do not overlap in the interior. So we suppose that C (v) and
C (v 0) do overlap in the interior. Note that each of the circumcircles C (v)
and C (v 0) contains exactly three points in the set S on its boundary, and
by Lemma 5.2.3, no point of S is contained in the interior of C (v ) or C (v 0).
Moreover, C (v ) and C (v 0) cannot be coincide otherwise at least four points
in the set S would be co-circular. Moreover, no one of the circles C (v ) and
C (v 0) can be entirely contained in the other, since otherwise some point of
the set S would be contained in the interior of C (v ) or C (v 0), contradicting
to Lemma 5.2.3. So the boundaries of the circumcircles C (v ) and C (v 0) must
intersect at exactly two points q and q 0. See Figure 7.1.
The two points q and q 0 partition the circle C (v ) into two disjoint curves,
one is entirely contained in the circle C (v 0) and the other is completely
outside the circle C (v 0). No vertex of the triangle 4(v ) can be on the curve
of C (v ) that is entirely contained in the circle C (v 0) otherwise that vertex,
which is a point in the set S , would be in the interior of the circle C (v 0),
contradicting Lemma 5.2.3. Thus the three vertices of 4(v ) must be on the
curve of C (v ) that is outside C (v 0). Similarly, the three vertices of 4(v 0) are
116 REDUCTIONS
p
4 p
2
v'
v
q
q'
q"
p
3
p
1
Figure 7.2: A point q outside all triangles
on the curve of C (v 0) that is outside C (v ). Therefore, the three vertices of the

triangle 4(v ) and the three vertices of the triangle 4(v 0) must be separated
by the segment qq 0 , so the triangles 4(v ) and 4(v 0) do not overlap in the
interior.
Lemma 7.3.2 Every point in the convex hull CH(S) is contained in some
triangle 4(v ) for some Voronoi vertex v of Vor(S).
proof. Suppose that the lemma is not true and that some point q in
CH(S) is not contained in any such triangles. Then we can nd a triangle
4(v), where v is a Voronoi vertex of Vor(S), and an interior point q0 in
the triangle 4(v ) such that the segment qq 0 intersects no triangles in D(S )
except the triangle 4(v ). Moreover, we can suppose that the segment qq 0
intersects 4(v ) at a unique point that is not a vertex of 4(v ). This condition
can be always satised since we can move the point q 0 slightly in the triangle
4(v).
Therefore, we can suppose that the triangle 4(v ) has three vertices p1 ,
p2 , and p3, that the segment qq 0 intersects the edge p1 p2 of 4(v) at an
internal point q 00, and that no points on the segment qq 00 (excluding the
point q 00) are contained in any triangle 4(u) for some Voronoi vertex u.
See Figure 7.2. Then the point p3 and the point q are on dierent sides of
the segment p1 p2. Since both points q and p3 are contained in the convex
hull CH(S), the segment p1 p2 cannot be a boundary edge of CH(S). Let
e = fv; v 0g be the Voronoi edge dened by p1 and p2 (note that the vertex v
must be an end-point of e), then by Lemma 5.2.4, e is a nite edge since the
points p1 and p2 are not consecutive hull vertices on CH(S). So the Voronoi
MINIMUM SPANNING TREE 117
vertex v 0 is not the innite point, and v 0 must correspond to a triangle 4(v 0)
in the straight-line dual D(S ). By the denition of 4(v 0), two vertices of
4(v0) must be the points p1 and p2, and the other vertex p4 of 4(v0) must
be dierent from the point p3 since v 6= v 0. Since the two triangles 4(v )
and 4(v 0) do not overlap in the interior, by Lemma 7.3.1, the two points
p3 and p4 must be on dierent sides of the segment p1p2 . Consequently,
however, some points on the segment qq 00 which are very close to the point
q 00 would be contained in the interior of the triangle 4(v 0). This contradicts
our assumption that no points on qq 00 (excluding q 00) is contained in any such
triangles. This contradiction shows that q must belong to a triangle 4(w)
for some Voronoi vertex w in Vor(S).
By Lemma 7.3.1 and Lemma 7.3.2, we obtain immediately that the
straight-line dual D(S ) of the Voronoi diagram Vor(S) is a triangulation
of the set S . This triangulation of S is called the Delaunay Triangulation of
the set S .
Theorem 7.3.3 TRIANGULATION /n VORONOI-DIAGRAM.
proof. Given a set S of n points in the plane, which is an input to the
problem TRIANGULATION, we simply pass S to the problem VORONOI-
DIAGRAM. The solution to VORONOI-DIAGRAM on input S is the
Voronoi diagram Vor(S) of S . Then from the Voronoi diagram Vor(S), we
construct the Delaunay Triangulation D(S ) of S by tracing all the Voronoi
edges of Vor(S). If the Voronoi diagram Vor(S) is given by a DCEL, then it
is easy to see that the Delaunay Triangulation D(S ) of S can be constructed
from Vor(S) in linear time.
Since the Voronoi diagram of a set of n points in the plane can be con-
structed in time O(n log n), by Corollary 7.0.2, we have
Corollary 7.3.4 The problem TRIANGULATION can be solved in time
O(n log n). In particular, the Delaunay triangulation D(S ) of a set S of n
points in the plane can be constructed in time O(n log n).
7.4 Euclidean minimum spanning tree

Consider the following problem: given a set S of n points in the plane,
interconnect all the points by straight line segments so that the total length
118 REDUCTIONS
of the segments is minimum. This problem has an obvious application in
computer networking where we want to interconnect all the computers at
minimum cost.
It is easy to see that the resulting connected PSLG after the above in-
terconnection must be a tree. In fact, if the resulting PSLG were not a tree,
then we would be able to nd a cycle, delete an edge from the cycle, and still
keep the PSLG connected. But this would contradict the assumption that
the resulting connected PSLG has the minimum total length of its edges.
This tree is called a Euclidean minimum spanning tree (EMST) of the set
S . In general, the Euclidean minimum spanning tree of a set is not unique.
The problem of nding Euclidean minimum spanning tree for a set of
points in the plane is closely related to the following problem of nding the
minimum weight spanning tree: given a weighted graph G, nd a spanning
tree of G with the minimum total weight. In fact, the problem of nding
Euclidean minimum spanning tree can be reduced to the problem of nding
minimum weight spanning tree, as we illustrate as follows.
Let S be a set of n points in the plane. To construct a Euclidean mini-
mum spanning tree of S , we can regard S as a weighted complete graph GS
of n vertices, such that the weight of an edge e = fp; p0g in GS , where p and
p0 are two points in S , is the Euclidean distance between p and p0 . There-
fore, a Euclidean minimum spanning tree of the set S is a minimum weight
spanning tree of the graph GS , and vice versa. There are a few ecient algo-
rithms constructing the minimum weight spanning tree for weighted graphs.
For example, Kruskal's algorithm [15] constructs the minimum weight span-
ning tree for a weighted graph with m edges in time O(m log m). However,
the complete graph GS has
(n2 ) edges. Therefore, a direct application of
Kruskal's algorithm to the complete graph GS would result in an O(n2 log n)
time algorithm for constructing a Euclidean minimum spanning tree for the
set S .
Interesting enough, with the help of the Voronoi diagram and the Delau-
nay Triangulation of the set S , a single preprocessing can eliminate most of
the edges of the complete graph GS from our consideration.
Lemma 7.4.1 Partition the set S into two non-empty disjoint subsets S1
and S2 . If p1p2 is the shortest line segment such that p1 2 S1 and p2 2 S2,
then the line segment p1 p2 is an edge in the Delaunay Triangulation D(S ).
proof. Suppose that the segment p1p2 is not an edge in D(S ). Then the
perpendicular bisector of p1p2 contains no Voronoi edge of Vor(S). Let V1
p
2
p3
e
q
p1
V1
Figure 7.3: p1 p2 intersects V1 at q
be the Voronoi polygon of the point p1 in the Voronoi diagram Vor(S), and
suppose that the segment p1p2 intersects the Voronoi polygon V1 at a point
q that is on the Voronoi edge e of V1 in Vor(S). (The point p2 cannot be
contained in V1 (including the boundary of V1) since V1 is the locus of points
closer to p1 than to any other points in S .) Suppose that the Voronoi edge
e is dened by the point p1 and another point p3 in S . See Figure 7.3. By
the denition, the points p1 and p3 are the closest points in S to the points
on the edge e. Therefore,
jp1p2j = jp1qj + jqp2j > jp1qj + jqp3j jp1p3j
Moreover, since we have 6 qp3 p1 = 6 p3 p1 q , and the point q is an internal
point of the segment p1p2 , we must have
6 p2 p3p1 > 6 qp3p1 = 6 p3 p1q = 6 p3 p1p2
Therefore, we have
jp1p2j > jp2p3j
Now we obtain a contradiction, since both segments p2p3 and p1 p3 are shorter
than the segment p1 p2 . Now if p3 2 S1 we pick p2 p3, and if p3 2 S2 we pick
p1p3. No matter what set the point p3 is in, we are always able to nd a
segment with one end in S1 and the other end in S2 such that the segment is
120 REDUCTIONS
shorter than p1 p2. This contradicts the assumption that p1 p2 is the shortest
such segment.
This contradiction proves that the segment p1 p2 must be an edge in the
Delaunay Triangulation D(S ) of the set S .
Lemma 7.4.2 Let p1 and p2 be two points in the set S . The segment p1p2
is an edge of some Euclidean minimum spanning tree if and only if there is
a partition of the set S into two non-empty sets S1 and S2 such that p1 p2 is
the shortest segment with one end in S1 and the other end in S2.
proof. Suppose that p1 p2 is an edge of a Euclidean minimum spanning
tree T . Then deleting the edge p1 p2 from T results in two disjoint subtrees
T1 and T2. Let S1 and S2 be the sets of points in S that are the vertices of
the trees T1 and T2, respectively. S1 and S2 obviously form a partition of
the set S and each of the sets S1 and S2 contains exactly one of the points
p1 and p2. We claim that the segment p1 p2 is the shortest segment with one
end in S1 and the other end in S2. In fact, if pp0 is a shorter segment with
one end in S1 and the other end in S2 , then in the tree T , replacing the
segment p1 p2 by the segment pp0 would give us a Euclidean spanning tree T 0
of S such that the sum of the edge lengths of T 0 is less than the sum of the
edge lengths of T . This contradicts the fact that T is a Euclidean minimum
spanning tree.
Conversely, suppose that there is a partition of S into two non-empty
subsets S1 and S2 such that p1p2 is the shortest segment with one end in
S1 and the other end in S2. Let T be a Euclidean minimum spanning tree
of S . If T contains p1p2 , then we are done. Otherwise, adding the segment
p1p2 to T results in a unique simple cycle C . Since the segment p1 p2 is on
the cycle C and p1 and p2 are in dierent sets of S1 and S2 , there must
be another segment pp0 on the cycle such that the points p and p0 are in
dierent sets of S1 and S2 . Since p1 p2 is the shortest segment with two
ends in dierent sets of S1 and S2, the segment pp0 is at least as long as the
segment p1p2 . Replacing the segment pp0 in T by the segment p1p2 gives
us a new Euclidean spanning tree T 0 of S such that the sum of the edge
lengths of T 0 is not larger than the sum of the edge lengths of T . Since T is
a Euclidean minimum spanning tree of S , the sum of the edge lengths of T 0
must be the same as that of T . Therefore, T 0 is also a Euclidean minimum
spanning tree and T 0 contains the segment p1p2 .
Corollary 7.4.3 If a segment p1p2 is an edge of some Euclidean minimum
spanning tree of the set S , then p1 p2 is an edge in the Delaunay Triangulation
D(S ) of the set S .
proof. The proof follows from Lemma 7.4.1 and Lemma 7.4.2 directly.
Therefore, the Delaunay Triangulation D(S ) contains all segments that

are in Euclidean minimum spanning trees of the set S . Now if we regard
D(S ) as a weighted graph GD(S) in which the weight of a segment p1 p2
in D(S ) is the Euclidean distance between the two points p1 and p2 , then
a Euclidean minimum spanning tree of the set S is a minimum weighted
spanning tree of the graph GD(S ) . This suggests the following algorithm.
Algorithm EMST(S)
Given: a set of n points in the plane

Output: a Euclidean minimum spanning tree of S
BEGIN
1. Construct the Delaunay triangulation D(S);
2. Construct a weighted graph G_D(S) that is
isomorphic to D(S) such that the weight of an
edge {p_i, p_j} in G_D(S) is the length of the
corresponding edge in D(S);
3. Apply Kruskal's algorithm to find a minimum
weight spanning tree T for G_D(S). This tree
T is a Euclidean minimum spanning tree for S;
END.
The analysis of the algorithm EMST is straightforward. By Corol-

lary 7.3.4, Step 1 for constructing the Delaunay triangulation D(S ) can
be done in time O(n log n). To construct the graph GD(S ), we simply com-
pute the length of each edge in D(S ). Since D(S ) is a planar graph of n
points, the number of edges of GD(S ) is bounded by O(n) (see Section 1.4).
So Step 2 can also be done in time O(n). Kruskal's algorithm runs in time
O(m log m) on weighted graphs with m edges. Since the graph GD(S) has
only O(n) many edges, the application of Kruskal's algorithm on CD(S ) takes
time O(n log n). This gives the following theorem.
Theorem 7.4.4 Given a set S of n points in the plane, the Euclidean min-
imum spanning tree of S can be constructed in time O(n log n).
122 REDUCTIONS
For the reason of completeness, we give a description of Kruskal's algo-
rithm. Since the algorithm has been well studied in the course of Algorithm
Analysis, we give only a brief outline of the algorithm and omit most of the
details. The interested reader is referred to [2].
Kruskal's algorithm nds the minimum weight spanning tree for a
weighted graph G by simply adding edges one at a time, at each step us-
ing the lightest edge that does not form a cycle. This algorithm gradually
builds up the tree one edge at a time from disconnected components. The
correctness of the algorithm follows from a theorem for weighted graphs that
is similar to our Lemma 7.4.2.
To implement Kruskal's algorithm, suppose that the number of vertices
of the graph G is n, and the number of edges of the graph G is m. We rst
presort all edges of G by their weight, then try to add the edges in order.
The presorting of edges of G takes time O(m log m). We then maintain a
forest F , which is a list of disjoint subtrees in the graph G. Each tree T in
the forest F is represented by a UNION-FIND tree whose leaf-nodes contain
the vertices of the tree T 1 (to distinguish the trees in the forest F , which
are the trees in the weighted graph G, from the UNION-FIND trees that
represent the trees in F , we call the vertices of the trees in F vertices, while
call the vertices of the UNION-FIND trees nodes). Initially, the forest F
is a list of n trivial trees, each is a single vertex of G. Pick the next edge
e = fv; ug from the sorted list of edges of G, and check if v and u are in the
same UNION-FIND tree in the forest F . This can be done by two FIND
operations followed by checking if the roots of the two UNION-FIND trees
are identical. If v and u are in the same UNION-FIND tree in the forest F ,
then adding e would result in a cycle in the forest F . So we should throw
the edge e. On the other hand, if v and u are in dierent UNION-FIND
trees in the forest F , then the edge e does not form a cycle in the forest F ,
so we should add the edge e to the forest F . This is equivalent to merging
the two UNION-FIND trees containing the vertices v and u in F . This
can be done by a single UNION operation. We keep adding edges until the
forest F contains a single tree, which is the minimum weight spanning tree
of the weighted graph G. Since for each edge in the graph, at most three
UNION-FIND operations are performed, to construct the nal minimum
weight spanning tree, we need at most 3m UNION-FIND operations. This
can be done in time O(m(m)), where (m) = o(log(m)) (see [2], Section 4.7
1 For detailed discussion of UNION-FIND problem, the reader is referred to [2], Sec-
tion 4.7.
MAX-EMPTY-CIRCLE 123
for detailed discussion). Now since m(m) = o(m log m), we conclude that
the running time of the Kurskal's algorithm is
O(m log m) + O(m(m)) = O(m log m)
7.5 Maximum empty circle

Given a set S of n points in the plane, the problem MAXIMUM-EMPTY-
CIRCLE is to nd a largest circle that contains no points of the set S and
whose center is internal to the convex hull of the set S . We will call such a
circle the maximum empty circle of the set S . The maximum empty circle
of a set S can be specied by its center and its radius.
We rst discuss where the center of the maximum empty circle can be
located.
Lemma 7.5.1 The center of the maximum empty circle of the set S must
be either a Voronoi vertex of Vor(S), or the intersection of a Voronoi edge
of Vor(S) and a boundary edge of the convex hull CH(S).
proof. Suppose that C is a maximum empty circle of the set S such that
C is centered at a point c.
Since C is the maximum empty circle, the boundary of the circle C must
contain at least one point of the set S , otherwise, we can increase the radius
of C (without moving the center c of C ) to get a larger empty circle.
If the boundary of C contains only one point p in the set S , then we can
move the center c of C away from the point p and increase the radius of C .
This contradicts our assumption that C is the maximum empty circle.
Consequently, the center c of the circle C cannot be in the interior of any
Voronoi polygon V of a point p of the set S , since otherwise, the point p is
the only closest point in S to the center c, so the boundary of the circle C
cannot contain any other points of S except p.
Therefore, the point c must be on a Voronoi edge of Vor(S) and the
boundary of the circle C contains at least two points of the set S . Now
suppose that c is not a Voronoi vertex of Vor(S), then there are exactly two
points p and p0 of the set S on the boundary of the circle C . If c is not
already on the convex hull, we can move it along the perpendicular bisector
of p and p0 away from both p and p0 (without getting out of the convex hull
CH(S)), and increase the radius of the circle C . This again contradicts the
assumption that C is the maximum empty circle of S .
124 REDUCTIONS
Therefore, the center c of the maximum empty circle must be either a
Voronoi vertex in Vor(S), or an intersection of a Voronoi edge and a boundary
edge of the convex hull of S .
Let c be a Voronoi vertex of Vor(S) or an intersection of a Voronoi
edge and a boundary edge of CH(S). The radius of the largest empty circle
centered at c can be computed easily. In fact, if c is a Voronoi vertex of
Vor(S), then c is equidistant from three points in the set S and no points of
S is in the interior of the circle dened by these three points (Lemma 5.2.3).
Therefore, the circle dened by these three points must be the largest empty
circle centered at c. On the other hand, if c is an intersection of a Voronoi
edge and a boundary edge of CH(S), then exactly two points p and p0 in S
are closest to c, so the largest empty circle centered at c must have radius
jcpj = jcp0j.
If the Voronoi diagram is given by a DCEL, then in constant time, we can
compute the radius of the largest empty circle centered at a Voronoi vertex
v, by an algorithm TRACE-VERTEX, which is similar to the algorithm
TRACE-REGION in Section 1.4, to trace all incident Voronoi edges and all
incident Voronoi polygons of the vertex v . (Note that a Voronoi vertex has
degree exactly 3.) Since the Voronoi diagram Vor(S) has only O(n) Voronoi
vertices (Lemma 5.2.6), in linear time we can construct all largest empty
circles that are centered at the Voronoi vertices of Vor(S). Note that not all
these circles are candidates of the maximum empty circle of S : those largest
empty circles that are centered at a Voronoi vertex that is outside the convex
hull CH(S) are disqualied. We will discuss later how to nd these Voronoi
vertices that are outside the convex hull CH(S).
Now let us discuss the points that are intersections of Voronoi edges
and the boundary edges of CH(S). The rst question is: how many such
intersections can we have?
Lemma 7.5.2 There are at most O(n) intersections of Voronoi edges and
the boundary edges of CH(S).
proof. Since the convex hull CH(S) is convex, a Voronoi edge, which
is a single straight line segment or a single straight semi-innite ray, can
intersect CH(S) at at most two points. Moreover, by Lemma 5.2.6, the
Voronoi diagram Vor(S) has at most O(n) Voronoi edges.
The following observation is also important.
Lemma 7.5.3 Each boundary edge of the convex hull CH(S) intersects at
least one Voronoi edge of Vor(S).
proof. If a boundary edge e = fv; v 0g of CH(S) does not intersect any
Voronoi edge, then the whole segment vv 0 is contained in a single Voronoi
polygon of Vor(S). But this is impossible, since the points on vv 0 that are
very close to the point v should be contained in the Voronoi polygon of v ,
while the points on vv 0 that are very close to the point v 0 should be contained
in the Voronoi polygon of v 0 .
For simplicity, call the intersections of the Voronoi edges of Vor(S) and
the boundary edges of CH(S) that are not a Voronoi vertex, the intersecting
points. An intersecting point p2 is the successor of an intersecting point p1
if the partial chain on the boundary of the convex hull CH(S) from p1 to p2 ,
in clockwise ordering, contains no other intersecting points.
Lemma 7.5.4 If we trace the boundary of a Voronoi polygon clockwise,
starting from an intersecting point p and leaving the convex hull, then we
must encounter at least another intersecting point. The rst intersecting
point after p we encounter must be the successor of p.
proof. Let the Voronoi polygon we are going to travel be V . Since the
point p is on the boundary of V and is an intersecting point, the Voronoi
polygon V must have at least one vertex inside the convex hull CH(S) and at
least one vertex outside the convex hull CH(S). Now since we are traveling
the boundary of V and leaving the convex hull CH(S), we must eventually
come back and enter the convex hull CH(S) in order to reach the vertices of
V that are inside CH(S). Therefore, the boundary of the polygon V must
intersect CH(S) at at least another point. Let p0 be the rst intersecting point
after p we encounter. Since both the partial chain of V between p and p0 ,
and the partial chain of CH(S) between p and p0 make only right turns, and
because both V and CH(S) are convex, the partial chain of CH(S) between
p and p0 must be entirely contained in the Voronoi polygon V . That implies
that no intersecting points are between the points p and p0 on the partial
chain of CH(S). Therefore, the intersecting point p0 is the successor of the
intersecting point p.
Now it is quite clear how we nd all intersecting points. We start with an
intersecting point p, travel the Voronoi polygon in the direction of leaving the
126 REDUCTIONS
convex hull CH(S). We will encounter another intersecting point p0, which
is the successor of the intersecting point p. At the point p0, we reverse the
traveling direction and start traveling the adjacent Voronoi polygon from the
point p0, again in clockwise order and in the direction of leaving the convex
hull CH(S). We will hit the successor of p0 , etc.. We keep doing this until
we come back to the rst intersecting point.
We summarize this in the following algorithm.
Algorithm FIND-ALL-INTERSECTIONS
Given: the Voronoi diagram Vor(S) and the convex

hull CH(S) of a set S of n points
Output: all the intersecting points of Vor(S) and
CH(S)
BEGIN
1. Find an intersecting point p_0;
2. Let p = p_0;
3. Travel a Voronoi polygon clockwise in the direction
of leaving the convex hull CH(S), starting from the
point p to find the successor p' of p;
4. If p' <> p_0 then replace p by p' and go back to
Step 3;
END.
We analyze the algorithm. Suppose that the Voronoi diagram Vor(S) is

given by a DCEL and the convex hull CH(S) is given by a circular doubly-
linked list.
To nd the rst intersecting point p0 , we pick any boundary edge e of
the convex hull CH(S). Then we scan the DCEL representing the Voronoi
diagram Vor(S) edge by edge and check which intersects e. By Lemma 7.5.3,
e intersects at least one Voronoi edge in Vor(S). So in linear time, we will
nd a Voronoi edge that intersects e and obtain the rst intersecting point
p0. So Step 1 of the algorithm can be done in linear time.
Starting from an intersecting point p, we travel the part of the Voronoi
polygon that is outside the convex hull CH(S). By Lemma 7.5.4, we will
encounter the successor of p. For this, we have to check, for each Voronoi
edge e we are traveling, if e intersects the convex hull CH(S). This seems
to need
(n) time to check all boundary edges of the convex hull CH(S)
for each Voronoi edge e. Fortunately, since each boundary edge of CH(S)
contains at least one intersecting point (Lemma 7.5.3), the successor of p
must be either on the boundary edge e of CH(S) where p is located, or on the
boundary edge of CH(S) that is next to e. Therefore, for each Voronoi edge
e we are traveling, we only have to check two boundary edges on CH(S).
So each Voronoi edge can be processed in constant time. Moreover, each
Voronoi edge that is outside the convex hull CH(S) is traveled at most twice
since each Voronoi edge is on the boundary of exactly two Voronoi polygons.
Therefore, the total time spent on Step 3 and Step 4 in the algorithm FIND-
ALL-INTERSECTIONS is bounded by the number of Voronoi edges that
are outside the convex hull CH(S), which is in turn bounded by the number
of Voronoi edges of the Voronoi diagram Vor(S), which is, by Lemma 5.2.6,
bounded by O(n).
Thererfore, the time complexity of the algorithm FIND-ALL-
INTERSECTIONS is bounded by O(n).
Finally, we discuss how to determine if a Voronoi vertex v is inside or out-
side the convex hull CH(S). In the algorithm FIND-ALL-INTERSECTIONS,
all the Voronoi vertices we encounter are outside the convex hull CH(S). So
we can simply mark them and not use them as potential candidates of the
center of the maximum empty circle. The question is, can there be any
Voronoi vertex that is outside the convex hull CH(S) and not encountered
by our algorithm FIND-ALL-INTERSECTIONS? The answer is NO, as ex-
plained by the following paragraph.
Suppose that v is a Voronoi vertex of Vor(S) and that v is outside of
the convex hull CH(S). Let v be on the boundary of some Voronoi polygon
V . The Voronoi polygon V cannot be completely outside the convex hull
Vor(S), since otherwise the corresponding point of the set S would be outside
the convex hull Vor(S). So the polygon V intersects CH(S) at at least two
points. Let p and p0 be two intersecting points of the polygon V and the
convex hull CH(S) such that the vertex v is contained in the partial chain
on the boundary of V from p to p0 in clockwise ordering, and that no other
intersecting points are on this partial chain. Then the algorithm FIND-ALL-
INTERSECTIONS will eventually encounter the intersecting point p and
trace this partial chain from p to p0. Now the vertex v must be encountered.
Summarizing the above discussions gives us the following algorithm for
solving the problem MAXIMUM-EMPTY-CIRCLE.
Algorithm MAXIMUM-EMPTY-CIRCLE
128 REDUCTIONS

Output: the maximum empty circle of S
BEGIN
1. Construct the Voronoi diagram Vor(S) and the
convex hull CH(S);
2. Call the subroutine FIND-ALL-INTERSECTIONS to
find all intersecting points of Vor(S) and CH(S),
and mark all Voronoi vertices that are outside
the convex hull CH(S);
3. For each q of such intersecting points, compute
the largest empty circle centered at q;
4. For each unmarked Voronoi vertex v, compute the
largest empty circle centered at v;
5. The largest among the largest empty circles
constructed in Step 3 and Step 4 is the maximum
empty circle of S;
END.
Step 1 takes time O(n log n), by Theorem 5.3.6 and by, say, the Graham
Scan algorithm. Step 2 takes linear time, as we have discussed above. The
other steps in the algorithm trivially take only linear time, by Lemma 5.2.6
and Lemma 7.5.2. Therefore, we obtain the following theorem.
Theorem 7.5.5 The problem MAXIMUM-EMPTY-CIRCLE can be solved
in time O(n log n).
7.6 All-farthest vertex

The \inverse" of the problem ALL-NEAREST-NEIGHBOR is the problem
ALL-FARTHEST-NEIGHBOR, in which we are asked to nd the farthest
neighbor for each point of a given set. The ALL-FARTHEST-NEIGHBOR
problem can be solved through the Farthest Neighbor Voronoi Diagram.
It can be shown that given a set S of n points in the plane, the Far-
thest Neighbor Voronoi Diagram of S can be constructed in time O(n log n).
Moreover, with the Farthest Neighbor Voronoi Diagram, the problem ALL-
FARTHEST-NEIGHBOR can be solved in another O(n log n) time, using the
techniques of point location, as we discussed in Chapter 5. Therefore, the
ALL-FARTHEST-NEIGHBOR problem can be solved in time O(n log n).
ALL-FARTHEST VERTEX 129
v5 v4
v6
v3
v7
v2
v8 v1
Figure 7.4: The vertices v1 and v3 are not an antipodal pair
In this section, we will discuss a restricted version of the problem ALL-

FARTHEST-NEIGHBOR, the all-farthest-vertex problem for the set of ver-
tices of a convex polygon. The goal is for each vertex of the convex polygon
nd the farthest vertex. Since the problem is \simpler" than the general
problem, we expect a better algorithm, say, a linear time algorithm for solv-
ing this problem.
Let us rst formally dene the ALL-FARTHEST-VERTEX problem.
ALL-FARTHEST-VERTEX
For each vertex v of a convex polygon P , nd a vertex of P that is farthest
from v .
It would seem a simple generalization of the algorithm for nding the
diameter of a convex polygon, as we showed in Section 3.3. That is, the
farthest vertex of a vertex v must be a vertex that constitutes an antipodal
pair with v . We rst show that this intuition is incorrect.
Look at the Figure 7.4. The vertex v3 is obviously the farthest vertex
from the vertex v1 . However, since the vertex v5 is the rst farthest vertex
from the edge v8 v1, by Lemma 4.3.4, the vertices v1 and v3 are not an
antipodal pair.
To solve the problem ALL-FARTHEST-VERTEX, we rst make an as-
sumption that for each vertex v of P , the distances from v to any two vertices
u and w of P are dierent. This assumption loses no generality since we can
dene the distance from v to a vertex u to be a triple D(v; u) = (d; x; y ),
130 REDUCTIONS
- ∞
-∞
Figure 7.5: The matrix MP
where d is the Euclidean distance between v and u, while x and y are the
x- and y-coordinates of the vertex u, respectively. The distance D(v; u) is
ordered lexicographically.2 With this assumption, each vertex of P has a
unique farthest neighbor.
7.6.1 A monotone matrix

Let the vertices of a convex polygon P be given in counterclockwise order
(v1 ; v2; ; vn ). It is convenient to describe the problem ALL-FARTHEST-
VERTEX in terms of an n (2n ? 1) matrix MP pictured in Figure 7.5.
In the ith row of MP , the cell (i; i + k) holds the distance D(vi ; vk0 ) (where
k0 = ((i + k ? 1) (mod n)) + 1), for 1 i n and 0 k n ? 1. All other
cells of MP hold ?1. Solving the problem ALL-FARTHEST-VERTEX is
equivalent to nding the maximal element in each row of the matrix MP .
Note that we are not actually constructing the matrix MP in the imple-
mentation of our algorithm. There are
(n2 ) elements in the matrix MP , so
even writing the matrix MP out takes time
(n2). Instead, we keep a list
for the indices of the rows and a list for the indices of the columns of the
matrix MP . Given a pair of indices (i; j ), the element with the index (i; j )
in the matrix MP can be computed in constant time.
The matrix MP has a very nice property, called monotone property.
2 Note that the distance D(v; u) is not symmetric, that is, in general, D(v; u) 6= D(u; v).
However, if D(v; u) is the largest then the vertex u must be one of the vertex of P that
has the farthest Euclidean distance from the vertex v.
Denition An n m matrix M = (ai;j ) is monotone if for any two pairs

(i1; i2) and (j1; j2) of indices, where 1 i1 < i2 n and 1 j1 < j2 m,
the 2 2 submatrix of M
!
ai1 j1 ai1j2
ai2 j1 ai2j2
has the property that it is not simultaneously possible that ai1 j1 < ai1 j2 and
ai2 j1 > ai2 j2 .
Lemma 7.6.1 The matrix MP is monotone.

proof. Given a 2 2 submatrix of MP
!
a b
c d
taken from the i1th and i2th rows and j1th and j2th columns of the matrix
MP , where i1 < i2 and j1 < j2. Suppose by contradiction that we have a < b
and c > d. Then b and c cannot be ?1.
The number a cannot be ?1. Otherwise since b 6= ?1 and a is on the
left of b in the matrix MP and a = ?1, so c must be ?1 since c is in the
same column as a and c is below a. But by our assumption, c is not ?1.
Similarly, the number d cannot be ?1.
So none of a, b, c, and d can be ?1. Now let us consider the relations
among the indices i1 , i2 , j1, and j2 .
Since the element c has index (i2; j1) and c 6= ?1, so we must have
i2 j1. If i2 = j1 then c is the distance between the vertex vi1 to itself in
P , thus c = 0. But this is impossible since c > d and d 6= ?1. Thus we
must have i2 < j1. Therefore, we can write explicitly
i1 < i2 < j1 < j2
Therefore, the vertices vi1 , vi2 , vj1 and vj2 must appear on the convex poly-
gon P in exactly this order (the indices j1 and j2 actually take values
(mod n) + 1). See Figure 7.6. However, now the conditions a < b and c > d
implies that c + b > d + a. Since the polygon P is convex, c + b > d + a
says that the sum of the lengths of opposite sides of a convex quadrilateral is
132 REDUCTIONS
i1 i2
a
c
b
d j1
j2
Figure 7.6: The convex polygon P

greater than the sum of the lengths of the diagonals of the same quadrilateral.
However, this contradicts a fundamental theorem in elementary geometry.
(Remark: this is the only place we use the convexity of the polygon P .)
Therefore, if we suppose that a < b and c > d, then we are always able
to derive a contradiction. This proves that a < b and c > d cannot be
simultaneously possible. That is, the matrix MP is monotone.
Corollary 7.6.2 Every submatrix of the matrix MP is monotone.
proof. This is because that each 2 2 submatrix of a submatrix of MP
is also a submatrix of MP .
Lemma 7.6.1 and Corollary 7.6.2 are crucial for the algorithms we are
going to give.
7.6.2 Squaring a monotone matrix
The matrix MP is a rectangle matrix that contains more columns than rows.
Since we are only interested in nding the maximal element in each row of
the matrix, at most n columns are really useful to us. In the following, we
will discuss how to square a rectangle matrix without deleting the maximal
element in each row. We will actually consider a little bit more general
case, that is, how do we square a rectangle submatrix of MP that has more
columns than rows such that the maximal element in each row is kept in the
resulting square matrix.
Let 0 1
a1;1 a1;2 a1;h
B a2;1 a2;2 a2;h CC
M =B
B@ CA
ar;1 ar;2 ar;h
be an r h submatrix of the matrix MP . By Corollary 7.6.2, the matrix M
is monotone.
Now let us look at the rst row, compare the elements a1;1 and a1;2. If
a1;1 < a1;2, then no maximal element in any row can be in the rst column.
In fact, a1;1 is not the maximal element in the rst row. Suppose that the
maximal element of the ith row of M is in the rst column, i > 1, then we
have ai;1 > ai;2 . This together with a1;1 < a1;2 contradicts the fact that M
is a monotone matrix. Therefore, the rst column of M can be deleted in
this case. After deleting the rst column of M , we compare the elements
a1;2 and a1;3. Similarly, if a1;2 < a1;3 then we can delete the second column
of M and compare the elements a1;3 and a1;4 and so on. We keep doing this
until we nd an index i1 such that a1;i1 > a1;i1 +1 . Now we save the column
i1 and move to the second row of M .3
We look at the second row and compare the elements a2;i1 +1 and a2;i1+2 .
If a2;i1 +1 a2;i1 +2 then we save the (i1 + 1)st column of M and move to the
third row. On the other hand, if a2;i1 +1 < a2;i1 +2 , then none of the 2nd, 3rd,
, rth rows of M can have their maximal element in the (i1 + 1)st column
of M because M is monotone. Moreover, since we know that a1;i1 > a1;i1+1 ,
the rst row of M does not have its maximal element in the (i1 +1)st column
either. Therefore, the (i1 + 1)st column of M contains no maximal elements
for any row, thus can be deleted. Now since we know no relation between
the elements a1;i1 and a1;i1+2 , so after deleting the (i1 + 1)st column, we
move back to the rst row and compare a1;i1 and a1;i1 +2 .
Now we discuss the general case. Inductively, suppose that we have
moved to the kth row of M with 2 k r ? 1, and we have saved the i1 th,
i2th, , and ik?1 th columns of M such that
a1;i1 > a1;i2
a2;i2 > a2;i3
3 Itseems that we have ignored the equality case, i.e., the case when a1;i1 = a1;i1 +1 .
However, the equality case can never happen. It is because that by our denition of the
distance D(v; u), vertex v has a unique distance to a vertex u. So case a1;i1 = a1;i1 +1
happens if and only if both a1;i1 and a1;i1 +1 are ?1. But by our selection of i1 , a1;i1 can
never be ?1.
134 REDUCTIONS

ak?2;ik?2 > ak?2;ik?1
ak?1;ik?1 > ak?1;ik?1 +1
and none of the deleted columns contain maximal elements of any row of
M . Then we compare the elements ak;ik?1 +1 and ak;ik?1 +2 in the kth row
of M . If ak;ik?1 +1 > ak;ik?1 +2 then we save the (ik?1 + 1)st column and
move to the (k + 1)st row of M . On the hand, if ak;ik?1 +1 < ak;ik?1 +2 ,
then for any j > k the j th row in the matrix M cannot have its maximal
element in the (ik?1 + 1)st column since M is monotone. Moreover, by
our inductive hypothesis, ak?1;ik?1 > ak?1;ik?1 +1 , so the (k ? 1)st row does
not have its maximal element in the (ik?1 + 1)st column. If for some j
such that j < k ? 1 such that the j th row has its maximal element in
the (ik?1 + 1)st column, then aj;ik?1 < aj;ik?1 +1 . But this together with
ak?1;ik?1 > ak?1;ik?1 +1 , contradicts the fact that the matrix M is monotone.
Summarizing these discussions, we conclude that the (ik?1 + 1)st column of
the matrix M contains no maximal element for any row, thus can be deleted.4
Now since we have no idea about the relation between the elements ak?1;ik?1
and ak?1;ik?1 +2 , we move back to the (k ? 1)st row of M and compare the
two elements.
The case for the last row (the rth row) should be treated specially. Sup-
pose that we have moved to the rth row of M , and we have saved the i1 th,
i2th, , and ir?1 th columns of M such that
a1;i1 > a1;i2
a2;i2 > a2;i3

ar?2;ir?2 > ar?2;ir?1
ar?1;ir?1 > ar?1;ir?1 +1
and none of the deleted columns contain maximal elements of any row of M .
We compare the elements ar;ir?1 +1 and ar;ir?1 +2 in the rth row of M . Again
there are two cases.
If ar;ir?1 +1 < ar;ir?1 +2 , then exactly as we have discussed for the case
2 k r ? 1, the (ir?1 + 1)st column of the matrix M contains no row
maximal elements, thus can be deleted. Moreover, since we have no idea
4 Again,since we can easily prove that ak;ik?1 +1 can never be ?1, we ignore the case
when ak;ik?1 +1 = ak;ik?1 +2 .
about the relation between the elements ar?1;ir?1 and ar?1;ir?1 +2 , we move
back to the (r ? 1)st row and compare the two elements.
On the other hand, if ar;ir?1 +1 > ar;ir?1 +2 , then ar;ir?1 +2 cannot be the
row maximal element for the rth row. Moreover, no other elements in the
(ir?1 +2)nd column can be row maximal elements, since otherwise we would
nd an index j < r such that
aj;ir?1 +1 < aj;ir?1 +2 and ar;ir?1 +1 > ar;ir?1 +2
contradicting the fact that the matrix M is monotone. Therefore, the (ir?1 +
2)nd column can be deleted. Now we compare the elements ar;ir?1 +1 and
ar;ir?1 +3 , and so on.
Keeping doing the above process, we will get a square matrix at some
moment. This can be shown as follows. Suppose that the number of columns
is greater than the number of rows. If we are at the kth row with 2 k
r ? 1, then either we will delete a column then move one row up or we will
move one row down without deleting any columns. If we are at the rst
row, then either we delete a column and remain in the rst row or we move
to the second row without deleting any columns. If we are at the last row,
then either we delete a column and move back to the (r ? 1)st row or we
delete a column and remain in the rth row. Therefore, only when we are
moving down we do not delete columns. However, we cannot move down
forever since eventually we will reach the last row, in which we have to delete
columns. By our inductive proof above, all maximal elements of the rows of
M are contained in the resulting square matrix.
We implement the above idea into the following algorithm SQUARE.
Suppose that the submatrix M of the matrix MP contains the elements in
the k1th, k2th, , kr th rows and the j1th, j2th, , jh th columns such that
k1 < k2 < < kr and j1 < j2 < < jh
and r < h. The indices k1, k2 , , kr are stored in a doubly-linked list Lrow ,
and the indices j1 , j2, , jh are stored in another doubly-linked list Lcol .
The algorithm SQUARE takes the two doubly-linked lists Lrow and Lcol as
its input, and outputs a doubly-linked list Lc that contains the indices of the
columns of M that are saved in the process. The list Lc contains r indices.
Since the lists are doubly-linked, for each element in a list, we can always
access in constant time the previous element in the list through a pointer
\last", and the next element in the list through a pointer \next".
136 REDUCTIONS
Algorithm SQUARE(L_row, L_col)
Given: a rectangle submatrix M of M_P, represented

by a list of row indices L_row and a list of
column indices L_col
Output: a square matrix M' obtained from M by deleting
some columns of M such that all row maximal
elements in M are kept in M'
BEGIN
1. Let L_c = L_col, let j and k be the first elements
in the list L_c and L_row, respectively;
2. WHILE the matrix is not square DO
2.1 CASE 1: k is the first element in the list L_row
IF a_{k, j} < a_{k, next(j)} THEN
let j = next(j) and delete the first element in
the list L_c
ELSE (* so a_{k, j} > a_{k, next(j)} *)
let j = next(j), and let k be the second element
in the list L_row,
2.2 CASE 2: k is neither the first nor the last in L_row
let j = last(j) and delete the old j from the
list L_c, and let k = last(k)
let k = next(k) and j = next(j);
2.3 CASE 3: k is the last element in the list L-row
let j = last(j) and delete the old j from the
list L_c, and let k = last(k);
let j = next(j), and delete the old j from the
list L_c
END of WHILE;
3. Output the list L_c;
END.
We analyze the algorithm. The algorithm is obviously dominated by

the WHILE loop (Step 2). First note that the value of an element ak;j in
the matrix M can be computed in constant time if we are given the convex
polygon P and the indices k and j . Therefore, each execution of the WHILE
loop takes constant time. Now let us discuss how many times the WHILE
loop in the algorithm can be executed. Note that whenever we move one row
up, we delete one column. To make the matrix square, we delete exactly h ? r
columns from the matrix M . So we can move up at most h ? r rows. This
also implies that we can move down at most r +(h ? r) = h rows. Thus, there
are at most 2h ? r executions of the WHILE loop that move on row up or
down. If an execution of the WHILE loop does not move a row up or down,
then we must be at the rst row or the last row, but then we must delete a
column. Thus, there are at most h ? r executions of the WHILE loop that
does not move on row up or down. Summarizing this together, we conclude
that the WHILE loop is executed at most 2h ? r + h ? r = O(h) times.
Consequently, the time complexity of the algorithm SQUARE is bounded
by O(h).
7.6.3 The main algorithm
Before we give the main algorithm for our problem, we consider the following
problem: let M be a monotone matrix, and suppose that the maximal ele-
ment of the ith row of M is in the j1 th column, while the maximal element
of the (i + 2)nd row of M is in the j2 th column, then what column of M
can the maximal element of the (i + 1)st row be in? Since the matrix M
is monotone, we must have j1 j2. Moreover, since M is monotone, the
maximal element of the (i +1)st row must be in a column that is between the
j1th column and j2 th column (including the j1 th column and j2th column
themselves). Therefore, instead of scanning the whole (i + 1)st row to nd
the maximal element, we only have to scan the elements in the (i + 1)st row
that are between the j1 th column and j2 th column.
Now we are ready for the main algorithm for the problem ALL-
FARTHEST-VERTEX. Suppose we are given a convex polygon P of n ver-
tices v1 , v2 , , and vn . Dene the matrix MP as above. The value of each
element ai;j of the matrix MP can be computed in constant time if we know
the indices i and j . We use the following algorithm to nd the farthest vertex
for each vertex of the convex polygon P . The subroutine ROW-MAXIMAL
takes an r r monotone submatrix M of MP as input and returns back a
list L of r indices such that for 1 i r, if the ith element in L is ki , then
the element ai;ki is the maximal element in the ith row of the submatrix M .
Algorithm ALL-FARTHEST-VERTEX(P)
138 REDUCTIONS
Given: a convex polygon P
Output: for each vertex of P, find the farthest vertex
BEGIN
1. Construct a doubly-linked list L_row containing
the indices 1, 2, ..., n, and a doubly-linked
list L_col containing the indices 1, 2, ...,
2n-1;
2. Call the subroutine SQUARE(L_row, L_col) to
obtain a list L_c of column indices of M_P
such that these columns constitute a square
submatrix of M_P that contains the maximal
element for each row of M_P;
3. Call the subroutine ROW-MAXIMAL(L_row, L_c);
4. Suppose that the subroutine ROW-MAXIMAL(L_row, L_c)
returns a list L, then for 1 <= i <= n,
if the ith element of L is k_i, then the vertex
v_{k_i'} is the farthest vertex from the vertex
v_i in the convex polygon P, where
k_i' = (k_i - 1)mod(n) + 1;
END.
The subroutine ROW-MAXIMAL is given as follows. Here we suppose

that M is a r r submatrix of the matrix MP , and the row indices and
column indices of M are given by two lists Lr and Lc , respectively.
Algorithm ROW-MAXIMAL(L_r, L_c)
Given: two doubly-linked lists L_r and L_c containing

the indices of rows and the columns of an r by
r submatrix M of the matrix M_P, respectively
Output: a list L of column indices such that the ith
element of L is the column index of the maximal
element in the ith row of the matrix M
BEGIN
1. IF L_c contains one element, return L_c directly;
2. Delete every other element from the list L_r. Let
the resulting list be L_r';
{ This is equivalent to deleting all rows with even
index from the matrix M. Let the resulting matrix
be M_1. M_1 consists of the rows of M that have
odd index. The matrix M_1 is an r/2 by r matrix. }
3. Call the subroutine SQUARE(L_r', L_c);
{ The algorithm SQUARE returns a list L_c' of size
r/2, which corresponds to a list of column indices
such that these columns constitute an r/2 by r/2
square matrix that contains all maximal elements
in the odd rows of the matrix M. }
4. Recursively call the subroutine ROW-MAXIMAL(L_r', L_c');
{ This recursive call will return a list L that contains
the column indices with which the maximal elements in
the odd rows are located. }
5. With the help of the list L, determine the column indices
for the maximal elements in the even rows of M. For this,
suppose in the (2 i - 1)st row of M, the maximal element
is in the j_1th column, and in the (2 i + 1)st row of M,
the maximal element is in the j_2th column, then scan the
elements in the (2i)th row only from column j_1 to column
j_2, the maximal element among these elements must be the
maximal element of the (2i)th row;
END.
Let us rst look at the time complexity of the algorithm ROW-

MAXIMAL. Step 1 and Step 2 can obviously done in time O(r), if the input
matrix M is an r r matrix. By the analysis of the algorithm SQUARE,
Step 3 can done in time O(r). Now look at Step 5. Suppose that the list L
contains (r=2) indices j1 , j2, , and jr=2, which are the column indices of
maximal elements of odd rows of M , then since the submatrix M is mono-
tone
j1 j2 jr=2
As we discussed before, to nd the maximal element in the (2i)th row, we
only have to scan the elements in the (2i)th row from the column ji to the
column ji+1 . Therefore, to nd maximal elements for all even rows, we will
scan at most
(j2 ? j1 + 1) + (j3 ? j2 + 1) + + (jr=2 ? jr=2?1 + 1) + (r ? jr=2 + 1)
= r=2 + r ? j1
= O(r)
elements. Therefore, the time for executing Step 5 is also bounded by O(r).
Let the time complexity of the algorithm ROW-MAXIMAL be T (r) when
the input is an r r matrix, then Step 4 in the algorithm takes time T (r=2),
140 REDUCTIONS
and all other steps take time O(r), so we have
T (r) T (r=2) + cn
where c is a constant. It is easy to see that T (n) = O(n). That is, the
algorithm ROW-MAXIMAL takes linear time.
Now we analyze the algorithm ALL-FARTHEST-VERTEX. Step 1 and
Step 4 obviously take time O(n). Since the algorithm SQUARE takes time
O(n), and by the analysis above, Step 3, the algorithm ROW-MAXIMAL
also takes time O(n), we conclude that the time complexity of the algorithm
ALL-FARTHEST-VERTEX runs in time O(n).
Theorem 7.6.3 The problem ALL-FARTHEST-VERTEX for convex poly-
gons can be solved in linear time.
7.7 Exercises
1. Give examples to show that a problem P 0 may have very high com-
plexity (e.g. NP-complete) even a linear time solvable problem P is
linear time reducible to P 0 .
2. A star-shaped polygon P = fp1; ; pn g is a simple polygon containing
at least one point q such that the segment qpi lies entirely within P
for all 1 i n. The problem STAR-POLYGON is to nd a star-
shaped polygon whose vertex set is the given set of points in the plane.
Show that the problem CONVEX HULL is linear time reducible to the
problem STAR-POLYGON.
3. Given a star-shaped polygon P , nd two vertices of P that are the
farthest apart.
4. Give a detailed proof that the problem CONVEX HULL is linear time
reducible to the problem VORONOI-DIAGRAM.
5. Consider the following problem in Robotics: Let S be a set of obstacles
on the plane. These obstacles are discs of the same radii. You have a
mobile \Robot" R which has shape of disc with a radius of 1. We want
an algorithm such that for any obstacle set S , and for any two points p
and q , the algorithm will nd a path for the robot R from position p to
position q , avoiding the obstacles. If no such path exists, the algorithm
EXERCISES 141
reports accordingly. Design and analyze an algorithm for this problem.
(Hint: construct the Voronoi diagram for the centers of the obstacles).
6. Given a set of n points in the plane, prove that the Delaunay triangu-
lation contains at most 2n ? 5 vertices and at most 3n ? 6 edges.
7. A monotone polygon is a simple polygon whose boundary can be de-
composed into two monotone chains (a chain is monoton if every ver-
tical line intersects it at at most 1 point). The problem MONOTON-
POLYGON is to nd a monoton polygon whose vertex set is the given
set of points in the plane. Show that the problem CONVEX HULL is
linear time reducible to the problem MONOTON-POLYGON.
8. Show that the problem CONVEX HULL is linear time reducible to the
following problem.
INTERSECTION-OF-HALF-PLANE
given a system of N linear inequalities of the form
ai x + bi y + ci 0 i = 1; 2; : : :; N:
nd the region of the solutions of it.
9. Show that the problem CONVEX HULL is linear time reducible to the
problem of constructing the convex hull of points in 3-dimension space
even if the points are given sorted with respect to the x-coordinates.
(Recall that the convex hull computation requires the reporting of
vertices, edges, and faces that lie on the convex hull and their adjacency
relations with respect to one another.)
10. Suppose that a problem P is reducible to a problem P 0 in O(n log n)
time and that the problem P 0 is solvable in time O(n log n). Is the
problem P necessarily solvable in time O(n log n)? Justfy your answer.
11. Given two sets A and B , with m and n planar points, respectively.
Find two points, one from each set, that are closest. (Hint: You
should consider the following three dierent cases: (1) m is much
larger than n; (2) n is much larger than m; (3) m and n are of the
same order.)
12. The problem All Nearest Neighbors is stated as follows: given a set S
of n points in the plane, nd a nearest neighbor of each. Show that
142 REDUCTIONS
this problem can be reduced in linear time to the problme Voronoi-
Diagram.
13. It has been recently shown that triangulating a simple polygon can
be done in linear time. Use this result to show that triangulating a
connected PSLG in which each face is a simple polygon can be done
in linear time.
14. Consider the following problem of SECOND CLOSEST PAIR: Given
a set S of n points in the plane, nd a pair of points p1 and p2 in S
such that the distance between p1 and p2 is the second shortest among
all pairs of points of S . (Of course, if there are two distinct closest
pairs, then either of them can be regarded as the second closest pair).
Show that the problem SECOND CLOSEST PAIR can be reduced to
the problem VORONOI DIAGRAM in linear time. Thus, it can be
solved in O(n log n) time.
15. Design an ecient algorithm that computes the area of an n-vertex
simple, but not necessarily convex polygon.
16. Design an ecient algorithm that nds the second farthest pair from
among n points in the plane.
17. Design a linear time algorithm for the following problem: given
Vor(S ), where S is a set of n points in the plane, nd a -chain (i.e.,
a path in Vor(S ) with both ends extended to innity) such that each
side of the -chain contains half of the points in S .
18. The Euclidean Traveling Saleman problem (ETS) is to nd a shortest
closed path through n given points in the plane. Show that an approx-
imate ETS tour whose length is less than twice the length of a shortest
tour can be constructed in time O(n log n). (Hint: reduce the problem
to the problem of Euclidean Minimum Spanning Tree problem.)
Chapter 8
Lower Bound Techniques

We have discussed quite a few algorithms for geometric problems, including
constructing convex hulls of nite sets of points in the plane, solving prox-
imity problems, nding the intersection of geometric objects, and searching
in PSLGs. Most of these problems can be solved by brute force methods
in time O(n2 ) or more. Our techniques (geometric sweeping, divide and
conquer, prune and search, and reduction) gives faster algorithms for solv-
ing these problems. Most of our algorithms run in linear time or in time
O(n log n). For those linear time algorithms, we know that we have ob-
tained asymptotically optimal solutions because even just reading the input
for the problems takes linear time. For those O(n log n) time algorithms,
however, a very natural question is whether we can further improve them,
or, equivalently, are these algorithms the best possible.
This question brings us to an important, deep, and in general dicult
branch in theoretical computer science, the study of lower bounds of prob-
lems. Here instead of designing a single ecient algorithm for a given prob-
lem, we want to prove that any algorithm solving the problem takes at least
certain amount of time.
Let us look at the problem of constructing convex hulls. We have dis-
cussed the relationship between constructing convex hulls and sorting (see
Section 6.1), we may have realized that an algorithm faster than O(n log n)
for convex hull is impossible, since as we have seen in Algorithm Analysis
that sorting n numbers requires at least
(n log n) comparisons (see, for
example, [2]), and since
SORTING /n CONVEX HULL
so the problem CONVEX HULL is at least as hard as SORTING. However,
143
144 LOWER BOUNDS
we are not completely satised with this result because the computational
model used is too restricted: it cannot even do multiplication! On the
other hand, just computing the standard Euclidean distance metric requires
quadratic polynomials.
In this chapter, we will introduce a general technique for deriving lower
bounds for geometric problems. We rst look closely at the computational
model that can do only comparison, the linear decision tree, then extend the
result on linear decision tree to a more powerful computational model, the
algebraic decision tree. Lower bounds then are obtained on this model for
most of the geometric problems we have discussed in the previous chapters.
Combining these lower bounds and the algorithms we have derived, we con-
clude that most of those algorithms developed in the previous chapters are
in fact optimal.
8.1 Preliminaries
Let us rst have a brief review of geometry. Let S be a subset of the n-
dimensional Euclidean space E n . S is connected if for any pair of points
p and q of S , there is a curve C adjoining them such that C is entirely
contained in S . By the denition, a convex set in E n is connected. Now
suppose that W is a subset of E n that is not necessarily connected, then a
connected component of W is a maximal connected subset of W . We will use
#W to denote the number of connected components of the set W .
A function f (x1; ; xn ) is a polynomial if f is a sum of terms of the form
cxi11 xi22 xinn , where c is a constant, and all ij 's are non-negative integers.
The degree of the term cxi11 xi22 xinn is dened to be the number i1 + i2 + +
in. The degree of a polynomial is the maximum of the degrees of its terms.
The function f is a linear polynomial if in each term of the above form, we
have ij 1, for all 1 j n. An equation f (x1; ; xn ) = 0 with f being
a linear polynomial denes a hyperplane in the n-dimensional Euclidean
space E n . An open inequality f (x1 ; ; xn) > 0 (or f (x1 ; ; xn ) < 0)
denes an open halfspace in E n, with the hyperplane f (x1 ; ; xn) = 0
being its boundary. Similarly, a closed inequality f (x1 ; ; xn) 0 (or
f (x1 ; ; xn) 0) denes a closed halfspace in E n, with the hyperplane
f (x1 ; ; xn) = 0 being its boundary. It is easy to see that hyperplanes,
open halfspaces, and closed halfspaces are all convex sets in E n .
Let S be the set of points (x1; ; xn) satisfying a sequence of relations:
fi (x1; ; xn) = 0 i = 1; ; m1
PRELIMINARIES 145
gj (x1; ; xn) > 0 j = 1; ; m2
hk (x1; ; xn ) 0 k = 1; ; m3
where all functions fi , gj , and hk , where i = 1; ; m1, j = 1; ; m2, and
k = 1; ; m3 are linear polynomials. Then S is the intersection of the
hyperplanes fi = 0, 1 i m1, the open halfspaces gj > 0, 1 j m2 ,
and the closed halfspaces hk 0, 1 k m3 . Since all hyperplanes, open
halfspaces, closed halfspaces are convex, by Theorem 3.1.1, the set S is also
convex.
A problem is a decision problem if it has only two possible solutions,
either the answer YES or the answer NO. Abstractly, a decision problem
consists simply of a set of instances that contains a subset called the set of
YES-instances. As we have studied in Algorithm Analysis, decision prob-
lems play a very important role in the analysis of NP-completeness. In
practice, many general problems can be reduced to decision problems such
that a general problem and the corresponding decision problem have the
same complexity.
There are certain problems where it is realistic to consider the number
of branching instructions executed as the primary measure of complexity.
In the case of sorting, for example, the outputs are identical to the inputs
except for order. It thus becomes reasonable to consider a model in which
all steps are two-way branches based on a \decision" that we should make
when computation reaches that point.
The usual representation for a program of branches is a binary tree called
a decision tree. Each non-leaf vertex represents a decision. The test repre-
sented by the root is made rst, and \control" then passes to one of its sons,
depending on the outcome of the decision. In general, control continues to
pass from a vertex to one of its sons, the choice in each case depending on
the outcome of the decision at the vertex, until a leaf is reached. The desired
output is available at the leaf reached. If the decision at each non-leaf vertex
of a decision tree is a comparison of a polynomial of the input variables with
the number 0, then the decision tree is called an algebraic decision tree.
It should be pointed out that although the algebraic decision tree model
seems much weaker than a real computer, in fact this intuitive feeling is not
very correct. First of all, given a computer program, we can always represent
it by a decision tree by \unwinding" loops in the program. Secondly, the
operations a real computer can perform are essentially additions and branch-
ings. All other operations are in fact done by microprograms that consists of
those elementary operations. For example, the value of sin(x) for a number
146 LOWER BOUNDS
x is actually obtained by an approximation of the Taylor's extension of the
function sin(x). Finally, we simply ignore the computation instructions and
concentrate on only branching instructions because we are working on lower
bound of algorithms. If we can prove that for some problem, at least N
branchings should be made, then of course, the number of total instructions,
including computation instructions and branching instructions, is at least
N.
Let us now give a less informal denition. We will concentrate on decision
tree models for decision problems.
Denition An algebraic decision tree on a set of n variables (x1; ; xn) is
a binary tree such that each vertex of it is labeled with a statement satisfying
the following conditions.
1. Every non-leaf statement L is of the form
if f (x1; ; xn) 1 0 then goto Li else goto Lj

where f (x1 ; ; xn) is a polynomial of x1 , , xn , and 1 is any com-
parison relation from the set f=; >; <; ; g. The statements Li and
Lj are the children of the statement L;
2. Every leaf statement is either a YES or a NO answer to the decision
problem.
If all polynomials at non-leaf vertices of an algebraic decision tree are

linear polynomials, then we call it a linear decision tree.
Let P be a decision problem with inputs of n real numbers. Then P
corresponds to a subset W of the n-dimensional space E n such that a point
(x1 ; ; xn ) 2 E n is in W if and only if the answer of the problem P to the
input (x1 ; ; xn) is YES. Let T be an algebraic decision tree that \solves"
the problem P in the following way: for any point p = (x1; ; xn) 2 E n ,
the answer of P to the input p is YES if and only if when we feed the root of
the algebraic decision tree T with the input p, then eventually we are led to
a YES leaf v in the tree T by following the decisions made on the non-leaf
vertices on the path from the root to the leaf v in the tree T . In this case,
we also say that the algebraic decision tree T accepts the subset W in E n .
8.2. ALGEBRAIC DECISION TREES 147
8.2 Algebraic decision trees
The depth of a tree is the length of the longest path from the root to a leaf
in the tree. It is easy to see that the depth of an algebraic decision tree
corresponds to the worst case time complexity of the tree. Therefore, to
derive a lower bound on the worst case time complexity of a problem P , it
suces to derive a lower bound on the depth of the algebraic decision trees
that solve the problem P . In this section, we show a lower bound on the
depth of an algebraic decision tree, assuming that we know the number of
connected components of the corresponding subset in E n the tree accepts.
We rst observe the following simple lemma.
Lemma 8.2.1 The depth of a binary tree with m leaves is at least dlog me.
Now suppose that P is a decision problem, and let W be the subset of
En that corresponds to the YES-instances of the problem P in E n . That
is, a point p = (x1 ; ; xn ) 2 E n is in the set W if and only if the solution
of the problem P to the input p is YES. Let T be an algebraic decision tree
that solves P , or equivalently that accepts the subset W .
Suppose in some way that the number #W of the connected components
of the set W is known. What can we say about the depth of the algebraic
decision trees that accept W ? We answer this question rst for the linear
decision tree model, then we extend the result to the algebraic decision tree
model.
Theorem 8.2.2 Let W be a subset of E n, and let T be a linear decision
tree of n variables that accepts the set W . Then the depth of T is at least
dlog(#W )e.
proof. Every path from the root to a leaf l in T corresponds to a sequence
of conditions:
fi (x1; ; xn) = 0 i = 1; ; m1
gj (x1; ; xn) > 0 j = 1; ; m2 (8:1)
hk (x1; ; xn ) 0 k = 1; ; m3
which are the testings occurring on the path. Each of these functions is a
linear polynomial since we assume that the tree T is a linear decision tree.
If we feed the root with a point p = (x1 ; ; xn ) in E n , then the point p
eventually goes to the leaf l if and only if the coordinates (x1; ; xn ) of p
148 LOWER BOUNDS
satises all the conditions in (8.1). Therefore, the leaf l corresponds to a set
Sl of points in E n that satisfy all the conditions in (8.1). Thus the set Sl
is the intersection of the hyperplanes, the open halfspaces, and the closed
halfspaces represented by these conditions. By the discussion we gave in
the last section, we conclude that the set Sl is convex. Consequently, Sl is
connected.
Now let l be a YES leaf, then the corresponding set Sl is a subset of the
set W . Since Sl is connected, by the denition of a connected component
that a connected component of W is a maximal connected subset of W , Sl
must be entirely contained in a single connected component of W . Therefore,
each YES leaf of the linear decision tree T only accepts points in a single
connected component of W . Since W has #W connected components, and
each point of W should be accepted by some YES leaf of T , we conclude
that the tree T contains at least #W YES leaves. Consequently, the number
of leaves of T is at least #W . Now by Lemma 8.2.1, the depth of the linear
decision tree T is at least dlog(#W )e.
The linear decision tree model seems too restricted (people would never
be happy if you tell them that their computers cannot do multiplication).
It is desired to extend the result above for the linear decision tree model to
the algebraic decision tree model. Let us see what is the obstacle to such an
extension. Suppose that an algebraic decision tree T accepts a subset W of
E n. Each YES leaf l of T accepts a subset Sl of the set W . The subset Sl is
again the intersection of the subsets presented by the conditions appearing
on the path from the root to the leaf l in the tree T . However, since the
polynomials at the non-leaves of T are not necessarily linear polynomials,
the set Sl may be not connected.1 Therefore, each leaf now can accept points
from many dierent connected components of W . Suppose that each leaf
can accept points from at most c connected components, then the only thing
we can conclude is that there are at least #W=c YES-leaves. Therefore, by
Lemma 8.2.1 again, we conclude that the depth of T is at least dlog(#W=c)e.
However, if the number c is of the same order as #W , then we will obtain a
trivial constant lower bound on the depth of the algebraic decision tree T .
However, if the number c above is bounded by some constant, then
dlog(#W=c)e will have the same order as dlog(#W )e, thus again we ob-
1 For example,
in the space E 2 , even a single condition with a non-linear polynomial
x2 ? y 2 1
denes a non-connected area.

DECISION TREES 149
tain a nontrivial lower bound on the depth of the algebraic decision tree
T . Therefore, we would like to know under what conditions the number c,
i.e., the maximum number of connected components whose points can be
accepted by a single leaf of an algebraic decision tree, can be bounded. Here
is a condition:
Theorem 8.2.3 (Milnor-Thom) Let S be the set of points in the n-
dimensional Euclidean space E n dened by the conditions
fi (x1; ; xn) = 0 i = 1; ; h (8:2)
where all fi , 1 i h, are polynomials of degree at most d. Then the
number #S of connected components of the set S is bounded by d(2d ? 1)n?1 ,
a number that is independent of the number of the conditions in (8.2).
The above theorem is a deep result in algebraic geometry. However, the
idea of the theorem is fairly intuitive: a polynomial of small degree denes
a subset of \simple shape" in a Euclidean space, and the intersection of
\simple-shape" subsets in a Euclidean space cannot have a very complicated
shape, that is, it cannot have many pieces of connected components.
Unfortunately, Milnor-Thom Theorem cannot be used directly to our
algebraic decision trees: it only covers the case of equalities, while our al-
gebraic decision trees also have inequalities. Thus it is necessary to extend
Milnor-Thom Theorem to cover inequalities.
Lemma 8.2.4 Let S be the set of points in the n-dimensional Euclidean
space E n dened by the following conditions
fi (x1; ; xn) = 0 i = 1; ; m1
gj (x1; ; xn) > 0 j = 1; ; m2 (8:3)
hk (x1; ; xn) 0 k = 1; ; m3
where all fi , gj , and hk , 1 i m1 , 1 j m2, and 1 k m3 , are
polynomials of degree at most d. Then the number of connected components
of the set S is bounded by d(2d ? 1)n+m2 +m3 ?1 .
proof. Suppose that S has r distinct connected components Ci , 1 i r,
arbitrarily pick a point pi = (x(1i); ; x(ni)) from the connected component
Ci , 1 i r. Now consider the rm2 real numbers
gj (x(1i); ; x(ni)) 1 j m2 ; 1 i r
150 LOWER BOUNDS
Note that all these rm2 real numbers are positive since all these points
pi = (x(1i) ; ; x(ni)), 1 i r, are in S . Let be the smallest real number
in these rm2 real numbers. Note that > 0.
Consider the set S 0 in E n dened by the following conditions
fi (x1; ; xn) = 0 i = 1; ; m1
gj (x1; ; xn) ? 0 j = 1; ; m2 (8:4)
hk (x1; ; xn) 0 k = 1; ; m3
We claim that the number of connected components of the set S 0 is at least
as large as the number of connected components of the set S . In fact, the
set S 0 is a subset of the set S since a point satisfying the conditions in
(8.4) obviously satises the conditions in (8.3). Therefore, no two connected
components of the set S can be \merged" into a single connected components
of the set S 0. Moreover, no connected components of S completely disappear
in S 0, since for each connected component Ci of S , at least the chosen point pi
satises all conditions in (8.4), by the denition of the number . Therefore,
instead of bounding the number of connected components of the set S , which
is dened by the equalities, the open inequalities, and the closed inequalities
of (8.3), we can work on a bound of the number of connected components of
the set S 0, which is dened by the equalities and the closed inequalities of
(8.4).
The technique of converting a closed inequality into an equality is well-
known in linear programming. For the set S 0 dened by the conditions
in (8.4), we introduce m2 + m3 new variables yj and zk , 1 j m2 ,
1 k m3 , and construct the following m1 + m2 + m3 conditions with
n + m2 + m3 variables xi , yj and zk , 1 i n, 1 j m2, and 1 k m3 :
fi (x1; ; xn) = 0 i = 1; ; m1
gj (x1; ; xn ) ? ? yj2 = 0 j = 1; ; m2 (8:5)
hk (x1; ; xn) ? zk2 = 0 k = 1; ; m3
00 n + m +m
Let S be the subset of E 2 3 that is dened by the conditions in
(8.5). It is easy to see that the number #S 00 of connected components
of S 00 is the same as the number #S 0 of connected components of S 0 ,
which is at least as large as the number #S of connected components
of the set S . By Milnor-Thom Theorem, the number #S 00 is bounded
by d(2d ? 1)n+m2 +m3 ?1 . Therefore, the number #S is also bounded by
d(2d ? 1)n+m2 +m3 ?1. This completes the proof.
DECISION TREES 151
Now similar as the proof for the case of linear decision trees, we can prove
a lower bound on the depth of general algebraic decision trees.
Denition An algebraic decision tree is of order d if all polynomials oc-
curring in the non-leaves of the tree have degree at most d.
Theorem 8.2.5 (Ben-or's Theorem) Let W be a subset of E n and let d

be a xed integer. Then any order d algebraic decision tree T that accepts
W has depth at least
(log #W ? n).
proof. Suppose that T is an order d algebraic decision tree that accepts
the set W . Let l be a YES leaf of the tree T that is associated with the
following conditions:
fi (x1; ; xn) = 0 i = 1; ; m1
gj (x1; ; xn) > 0 j = 1; ; m2 (8:6)
hk (x1; ; xn) 0 k = 1; ; m3
where all fi , gj , and hk , 1 i m1 , 1 j m2 , and 1 k m3 , are
polynomials of degree at most d.
Let Sl be the set accepted by the leaf l, that is, Sl is the set in E n dened
by the conditions in (8.6). Since m1 + m2 + m3 is the length of the path
from the root of T to the leaf, m1 + m2 + m3 is bounded by the depth h of
the algebraic decision tree T .
By Lemma 8.2.4, the number of connected components of the set Sl is
bounded by d(2d ? 1)n+m2 +m3 ?1 , which is bounded by d(2d ? 1)n+h?1 . Now
since the set W has #W connected components, and each point of W must
be accepted by some leaf of T , we conclude that the algebraic decision tree
T has at least #W=(d(2d ? 1)n+h?1 leaves. By Lemma 8.2.1, the depth h of
the tree T is at least
log( #W )
d(2d ? 1)n+h?1
From this, we get
h log(#W ) ? log d ? (n + h ? 1) log(2d ? 1)
That is
h 1 + log(2 1
d ? 1) (log(#W ) ? n log(2d ? 1) + log((2d ? 1)=d))
152 LOWER BOUNDS
When the number d is a xed constant, we get h =
(log(#W ) ? n).
Therefore, to derive the lower bound of a problem, we may consider the
corresponding set W in the space E n for all n, then compute the number of
connected components of the set W . We will use this technique to derive
non-trivial lower bounds for several problems.
8.3 Proving lower bounds directly

With the lower bound on the depth of algebraic decision trees obtained in the
last section, now we are ready to derive a few lower bounds for problems, in-
cluding the EXTREME-POINTS, ELEMENT-UNIQUENESS, UNIFORM-
GAP, and SET-DISJOINTNESS.
The basic idea is as follows: given a decision problem P , we try to
formulate the YES-instances of P with n parameters into a subset W of
the n-dimensional Euclidean space E n. Then we derive a lower bound B
on the number of connected components of the subset W . Now by Ben-or's
theorem, the logarithm of B gives us a lower bound on the depth of algebraic
decision trees that solve the problem P , that is in consequence a lower bound
on the computational time of the algebraic decision trees solving the problem
P.
8.3.1 Element uniqueness
We start with a simplest example, the problem of ELEMENT-
UNIQUENESS. The problem is formally dened as follows.
ELEMENT-UNIQUENESS
Input: A set S of n real numbers.
Question: Are there two numbers in S equal?
We derive a lower bound for the problem ELEMENT-UNIQUENESS by
using Ben-or's theorem (Theorem 8.2.5) directly.
Theorem 8.3.1 Any bounded order algebraic decision tree that solves the
problem ELEMENT-UNIQUENESS runs in time at least
(n log n).
proof. Adopting the standard technique, we rst consider the number of
PROVING DIRECTLY 153
connected components of the following set in the n-dimensional Euclidean
space.
W = f(x1; ; xn) j all xi 's are distinctg
A point (x1 ; ; xn ) in n-dimensional Euclidean space is a YES-instance of
the problem ELEMENT-UNIQUENESS if and only if the point belongs to
the set W .
Fix a point (x1 ; ; xn ) in n-dimensional Euclidean space such that all
xi 's are distinct. Consider the n! points in the n-dimensional Euclidean space
obtained by permuting (x1; ; xn ).
P = (x(1); ; x(n)) is a permutation of (1; ; n)
Clearly, all these n! points are in the set W . We claim that no two of these
n! points share the same connected component of W . In fact, suppose that
and 0 are two dierent permutations of (1; ; n) and that the points
P and P0 are in the same connected component of W , then there is a
continuous curve C in W connecting P and P0 . That is, we can nd n
continuous functions fi (x), 1 i n, such that
fi (0) = x(i) and fi(1) = x0(i) for 1 i n
Since and 0 are dierent permutations of (1; ; n), we can nd an
index k such that x(k) is the smallest number such that x(k) 6= x0 (k) .
Suppose that x(k) = x0 (h) for some index h 6= k, then we also have x(h) 6=
x0 (h) . So
x(k) < x(h) and x0 (k) > x0 (h)
by the denition of the index k.
Since fk (x) and fh (x) are continuous functions and
fk (0) = x(k) fk (1) = x0 (k) fh(0) = x(h) fh (1) = x0 (h)
Thus
fk (0) < fh (0) and fk (1) > fh (1)
there must be a real number r in the interval (0; 1) such that fk (r) = fh (r).
However, by our assumption, the point (f1 (r); f2(r); ; fn (r)) on the curve
C is in the set W , so all numbers fi (r) are distinct. In particular, the
numbers fk (r) and fh (r) are distinct. This contradiction proves that each
point P is in a dierent connected component of the set W .
154 LOWER BOUNDS
Thus the set W has at least n! connected components. So #W n!.
Now since
n! = 1 2 n > n2 ( n2 + 1) n ( n2 ) 2
n
So we have
log(#W ) log(n!) log ( n2 ) 2 = n2 log( n2 ) =
(n log n)
n
By Ben-or's theorem (Theorem 8.2.5), any bounded order algebraic decision

tree that solves the problem ELEMENT-UNIQUENESS runs in time at least

(log(#W ) ? n) =
(n log n)
8.3.2 Uniform gap

Given a set S of real numbers, we say that numbers x and y are consecutive
if y is the smallest number in S ? fxg that is not less than x.
The UNIFORM -GAP problem is stated as follows, where is a xed
real number.
UNIFORM -GAP
Question: Are the distances between consecutive numbers in S uni-
formly equal to ?
problem UNIFORM -GAP runs in time at least
(n log n).
proof. The proof is quite similar to the proof of Theorem 8.3.1.
Consider the following set in the n-dimensional Euclidean space
W = f(x1 ; ; xn) j (x1; ; xn) is a YES-instance of UNIFORM -GAPg
Thus a point (x1; ; xn ) in n-dimensional Euclidean space is in the set W if
and only if there is a permutation of (1; ; n) such that x(i) + = x(i+1) ,
for 1 i n ? 1.
Fix a point (x1; ; xn ) in n-dimensional Euclidean space such that xi +
= xi+1 , for all 1 i n ? 1. Consider the n! points in the n-dimensional
Euclidean space obtained by permuting (x1; ; xn )
P = (x(1); ; x(n)) is a permutation of (1; ; n)
Clearly, all these n! points are in the set W . We claim that no two of these
n! points share the same connected component of W . In fact, suppose that
and 0 are two dierent permutations of (1; ; n) and that the points
P and P0 are in the same connected component of W , then there is a
continuous curve C in W connecting P and P0 . That is, we can nd n
continuous functions fi (x), 1 i n, such that
fi (0) = x(i) and fi(1) = x0(i) for 1 i n
Exactly the same as in the proof of Theorem 8.3.1, we can nd two indices
k and h such that
fk (0) < fh (0) and fk (1) > fh (1)
So there exists a real number r in the interval (0; 1) such that fk (r) =
fh (r). But then the point (f1 (r); f2(r); ; fn(r)) on the curve C cannot
be in the set W since the distance between the numbers fk (r) and fh (r)
is less than . This contradiction proves that the set W has at least n!
connected components. By Ben-or's theorem (Theorem 8.2.5), any bounded
order algebraic decision tree that solves the problem UNIFORM -GAP runs
in time at least

(log(#W ) ? n) =
(n log n)
8.3.3 Set disjointness

The third problem we study is the following problem.
SET-DISJOINTNESS
Given two sets X = fx1; ; xn g and Y = fy1 ; ; yn g of real numbers,
do they have an empty intersection?
For each instance (X; Y ) of the problem SET-DISJOINTNESS, where
X = fx1; x2; ; xng and Y = fy1 ; y2; ; yng, we associate it with a point
156 LOWER BOUNDS
in the 2n-dimensional Euclidean space E 2n:
(x1 ; y1; x2; y2; ; xn; yn )
This mapping gives us a one-to-one correspondence between the points in
E 2n and the instance of size n of the problem SET-DISJOINTNESS if we
suppose that the sets X and Y are \ordered sets". (We call (X; Y ) an
instance of size n if both the sets X and Y contain n real numbers.) Let
W be the subset of E 2n that corresponds to the YES-instances of size n of
the problem SET-DISJOINTNESS. We rst prove that W has at least n!
connected components.
Fix two sets X = (x1; x2; ; xn ) and Y = (y1 ; y2; ; yn ) of real numbers
such that
x1 > y1 > x2 > y2 > > xn > yn
Then (X; Y ) is a YES-instance of the problem SET-DISJOINTNESS which
corresponds to a point
p = (x1; y1 ; x2; y2; ; xn; yn)
in the 2n-dimensional Euclidean space E 2n. Thus the point p is in the set
W . Consider the n! points in E 2n that are obtained by permuting the n
components in p with even indices. That is, consider the n! points
p = (x1; y(1); x2; y(2); ; xn; y(n) )
where is a permutation of (1; 2; ; n).
Clearly, all these n! points p are in the set W . We claim that no two of
these n! points share the same connected component of W . In fact, suppose
that and 0 are two dierent permutations of (1; ; n) and that the points
p and p0 are in the same connected component of W , then there is a
continuous curve C in W connecting p and p0 . That is, we can nd 2n
continuous functions hi (t), fi (t), 1 i n, such that
hi (0) = hi (1) = xi for 1 i n
fi(0) = y(i) and fi(1) = y0(i) for 1 i n
Since and 0 are dierent permutations of (1; ; n), we can nd an index k
such that y(k) is the smallest number in (y1 ; ; yn ) such that y(k) 6= y0 (k) .
Since y(k) is the smallest in (y1 ; ; yn ), we have y(k) < y0 (k) . By the
denition of our point p, there must be an xl such that
y(k) < xl < y0 (k)
Now consider the function F (t) = hl (t) ? fk (t), we have
F (0) = hl(0) ? fk (0) = xl ? y(k) > 0
and
F (1) = hl(1) ? fk (1) = xl ? y0 (k) < 0
The function F (t) is continuous because hl (t) and fk (t) are. Therefore, there
is a real number such that 0 < < 1 and
F () = hl() ? fk () = 0
That is, hl () = fk (). However, by our assumption, the point
p0 = (h1(); f1(); h2(); f2(); ; hn(); fn())
on the curve C is in the set W , so every component hi () is distinct from any
component fj () in the point p0. In particular, the numbers hl () and fk ()
are distinct. This contradiction proves that each point P is in a dierent
connected component of the set W .
Thus the set W has at least n! connected components. So #W n!.
By Ben-or's theorem (Theorem 8.2.5), any bounded order algebraic decision
tree that solves the problem SET-DISJOINTNESS runs in time at least

(log(#W ) ? n) =
(n log n)
The above discussion gives the following theorem.
problem SET-DISJOINTNESS runs in time at least
(n log n).
8.3.4 Extreme points

The above three problems are combinatorial problems. In this subsection,
we derive a lower bound for a geometric problem that is called EXTREME-
POINTS problem, which is closed related to the problem CONVEX-HULL.
The proof is again similar to those given above, though slightly more com-
plicated.
Denition Let S be a set of points in the plane E 2. A point p 2 S is an
extreme point of S if p is on the boundary of the convex hull CH(S), and p
158 LOWER BOUNDS
is not an interior point of any boundary edge of CH(S).
The CONVEX-HULL problem is to nd all extreme points of a given
set S in the counterclockwise order with respect to some interior point of
CH(S). The following decision problem has an obvious relationship with the
CONVEX-HULL problem.
EXTREME-POINTS
Input: A list S of n points in the plane E 2.
Output: Are all points in S extreme points of S ?
The EXTREME-POINTS problem seems \simpler" than the CONVEX-
HULL problem since it is not required to check the counterclockwise order of
the extreme points on the boundary of the convex hull CH(S). We will see,
however, that it takes the same amount of time to solve the EXTREME-
POINTS problem as to solve the CONVEX-HULL problem.
A point p in the plane E 2 can be uniquely represented by a tuple of two
real numbers p = (x; y ), where x and y are the x- and y - coordinates of p,
respectively. Similarly, an ordered list of 2n points (p1; ; p2n) in the plane
E 2 can be uniquely represented by a tuple of 4n real numbers (p1 ; ; p2n ) =
(x1 ; ; x4n ), where pi = (x2i?1 ; x2i), for 1 i n. Therefore, each 2n-
point instance (p1 ; ; p2n ) for the EXTREME-POINTS problem uniquely
corresponds to a point in the 4n-dimensional space E 4n. Conversely, any
point (x1 ; ; x4n ) in the space E 4n can be regarded uniquely as a 2n-point
instance for the EXTREME-POINTS problem, if we let pi = (x2i?1 ; x2i), for
1 i 2n. Therefore, the set of 2n-point YES-instances of the EXTREME-
POINTS problem is a subset of the 4n-dimensional space E 4n . Note that a
set of 2n points S = fp1; ; p2ng in the plane E 2 can correspond to up to
(2n)! dierent ordered lists, thus (2n)! dierent points in the space E 4n , if
we consider all permutations of these 2n points. Thus any set of 2n points
in the plane makes (2n)! dierent instances for the EXTREME-POINTS
problem.
Lemma 8.3.4 Let W be the subset of the space E 4n that corresponds to the
set of 2n-point YES-instances for the EXTREME-POINTS problem. Then
W has at least n! connected components.
proof. We construct n! points in the set W and prove that no two of
these points are contained in the same connected component of the set W .
Let I = (p1; q1 ; p2; q2 ; ; pn ; qn ) be a counterclockwise sequence of 2n
distinct extreme points of a convex polygon. Then I 2 E 4n is a point in the
set W . Consider the following n! dierent sequences of 2n-point instances
of the problem EXTREME-POINTS:
Ii = (p1; q1(i); p2; q2(i); ; pn; qn(i)) i = 1; ; n! (8:7)
where each sequence (q1(i); q2(i); ; qn(i)) is a permutation of the sequence
(q1 ; q2; ; qn ). Each instance Ii corresponds to a point in the space E 4n .
Since each instance Ii shares the same set of points fp1; q1; ; pn ; qn g in the
plane E 2 with the instance I and the I is a YES-instance of the problem
EXTREME-POINTS, the instance Ii should also be a YES-instance of the
problem EXTREME-POINTS (i.e., every point in Ii is an extreme point).
That is, the instance Ii , for 1 i n!, corresponds to a point in the set W .
Now we prove that any pair of instances (8.7) are in two dierent con-
nected components of the set W . Suppose otherwise, there are two instances
Ii and Ij in (8.7) that are two points in E 4n and in the same connected com-
ponent of the set W . Then there is a continuous curve C in E 4n that adjoins
the two points Ii and Ij . More precisely, there are 2n continuous functions
on the interval [0, 1]
S1(t); T1(t); S2(t); T2(t); ; Sn(t); Tn(t)
such that Sh (0) = Sh (1) = ph , and Th (0) = qh(i) and Th (1) = qh(j ), for
h = 1; 2; ; n, and for all t 2 [0; 1], the point
(S1(t); T1(t); S2(t); T2(t); ; Sn(t); Tn(t))
is in the set W .
Since Ii and Ij are two dierent instances in (8.7), there must be an index
k such that qk(i) and qk(j) are dierent points in the set fq1 ; q2; ; qng. With-
out loss of generality, suppose the qk(i) = q1 then qk(j ) 6= q1 . Then the signed
triangle area 4(p1qk(i)p2 ) is positive while the signed triangle area 4(p1qk(j ) p2 )
is negative, because the only point q in fq1 ; q2; ; qn g that makes p1 qp2 a
left turn is the point q1 . Since S1 (t), Tk (t), and S2(t) are continuous func-
tions of t, the signed triangle area 4(S1(t)Tk (t)S2 (t)) is also a continuous
function of the variable t. Moreover, since we have 4(S1(0)Tk (0)S2(0)) =
4(p1qk(i)p2) > 0 and 4(S1(1)Tk(1)S2(1)) = 4(p1qk(j)p2) < 0, there must be
160 LOWER BOUNDS
a number t0 2 (0; 1) such that 4(S1(t0 )Tk (t0 )S2(t0 )) = 0. That is, on the
curve C in E 4n , there is a point
I0 = (S1(t0); T1(t0); S2(t0 ); T2(t0 ); ; Sn(t0 ); Tn(t0 ))
such that S1 (t0 ), Tk (t0 ), and S2(t0 ) are three co-linear points in the plane
E 2. Therefore, at least one point in the set fS1(t0 ); Tk (t0 ); S2(t0 )g is not an
extreme point of the set of 2n points
fS1(t0); T1(t0); S2(t0); T2(t0); ; Sn(t0); Tn(t0)g
Thus the instance
I0 = (S1(t0 ); T1(t0 ); S2(t0); T2(t0 ); ; Sn(t0 ); Tn(t0 ))
should be a NO-instance of the problem EXTREME-POINTS, so I0 62 W .
This contradicts the assumption that the entire curve C is contained in the
set W . The contradiction proves that no two points in (8.7) can be in the
same connected component of the set W . Since there are n! dierent points
in (8.7), we conclude that the set W has at least n! connected components.
We say that an algebraic decision has a bounded order if the order of

the tree is bounded by a constant that is independent of the input size of
the tree. Now combining the lemma above with Theorem 8.2.5, we easily
obtained a lower bound for the problem EXTREME-POINTS.
problem EXTREME-POINTS runs in time at least
(n log n) on an input
of n points in the plane.
proof. Remember that we are working on worst case time complexity.
Therefore, we only have to show that for some integer n, the theorem is true.
Let T be an order d algebraic decision tree that solves the problem
EXTREME-POINTS with inputs of n = 2m points in the plane. Thus
the number of input variables of the tree T is 2n = 4m. Let W be the
set of points in the space E 4m that are the YES-instances of the problem
EXTREME-POINTS. Then the algebraic decision tree T accepts the set W .
By Lemma 8.3.4, W has at least m! connected components. Now by Theo-
rem 8.2.5, the depth of the tree T is at least
(log(#W ) ? 4m). Since we
have
m! = 1 2 m > m2 ( m2 + 1)( m2 + 2) m > ( m2 ) 2
m
LOWER BOUNDS BY REDUCTION 161
Therefore,
log(#W ) log(m!) log(( m m log( m )
m
2
2 ) ) = 2 2
Now the depth of the algebraic decision tree T is
(log(#W ) ? 4m) =
(m log m) =
(n log n).
8.4 Deriving lower bounds by reductions

The techniques used in the last section for deriving lower bounds on problems
seem impressive. Such elegant techniques were developed and such deep
mathematics results were used in deriving the lower bounds. It is not clear
how these techniques can be generalized to deriving lower bounds for general
geometric problems. Fortunately, we do not have to do this very often. For
some geometric problems, the lower bounds can be derived by \reducing"
the problems to some other problems for which the lower bounds are known.
Let us rst review the concept of problem reductions. We say that a
problem P can be reduced to a problem P 0 in time O(t(n)), express it as
P /t(n) P 0 , if there is an algorithm T solving the problem P in the following
way.
1. For any input x of size n to the problem P , convert x in time O(t(n))
into an input x0 to the problem P 0 ;
2. Call a subroutine to solve the problem P 0 on input x0;
3. Convert in time O(t(n)) the solution to the problem P 0 on input x0
into a solution to the problem P on input x.
We have seen in Chapter 6 that the technique of reduction is very useful
in designing ecient algorithms for geometric problems. In this section, we
will study how to use this technique to derive lower bounds for geometric
problems. The following theorem plays an important role in our discussion.
Theorem 8.4.1 Suppose that a problem P is reduced to a problem P 0 in
linear time
P /n P 0
If it is known that solving the problem P takes at least
(T (n)) time, then
solving the problem P 0 also takes at least
(T (n)) time. In other words, a
162 LOWER BOUNDS
lower bound of the time complexity of the problem P is also a lower bound
of the time complexity of the problem P 0 .
proof. Suppose otherwise, the problem P 0 can be solved in time T1(n),
with T1 (n) = o(T (n)). Then by Lemma ??, the problem P can also be
solved in time O(T1(n)). But this would imply that the problem P can be
solved in time o(T (n)), contradicting our assumption that T (n) is a lower
bound on the time complexity of the problem P .
We rst use Theorem 8.4.1 to derive a lower bounds for the problem
CONVEX-HULL.
Theorem 8.4.2 Any bounded order algebraic decision tree that constructs
the convex hull for a set of points in the plane runs in time at least
(n log n)
on an input of n points in the plane.
proof. By Theorem 8.3.5, any bounded order algebraic decision tree that
solves the problem EXTREME-POINTS runs in time at least
(n log n).
According to Theorem 8.4.1, it will suce to prove the theorem by showing
that
EXTREME-POINTS /n CONVEX-HULL
We give this reduction by the following algorithm.
Algorithm REDUCTION I
{ Reduce the problem EXTREME-POINTS to the problem
CONVEX-HULL. }
BEGIN
1. Given an input S of the problem EXTREME-POINTS,
where S is a set of n points in the plane, pass
the set S directly to the problem CONVEX-HULL;
2. The solution of CONVEX-HULL to the set S is the
convex hull CH(S) of the set S. Pass CH(S)
back to the problem EXTREME-POINTS;
3. If the convex hull CH(S) has n hull vertices,
and no hull vertex is at the middle of the
straight line segment passing through its two
neighbors, then the answer of the problem
EXTREME-POINTS to the input S is YES;
Otherwise, the answer should be NO.
END.
Since both Step 1 and Step 3 take at most time O(n), the above algo-
rithm is a linear time reduction of the problem EXTREME-POINTS to the
problem CONVEX-HULL.
Thus constructing convex hulls of sets of points in the plane takes time
at least
(n log n). This result implies that many algorithms we discussed
before for construction of convex hulls, including Graham Scan, MergeHull,
Kirkpatrick-Seidel algorithm, are optimal.
As we have discussed in the last chapter, the problem CONVEX-HULL
can be reduced to the problem SORTING in time O(n). By Theorem 8.4.1
and Theorem 8.4.2, we also obtain
Theorem 8.4.3 Any bounded order algebraic decision tree sorting n real
numbers runs in time at least
(n log n).
This theorem is stronger than the one we got in Algorithm Analysis. In
Algorithm Analysis, it is proved that a linear decision tree model that sorts
runs in time
(n log n). On the other hand, Theorem 8.4.3 claims that even
the computation model is allowed to do multiplication, it still needs at least
(n log n) time to sort.

We have seen that many proximity problems can be solved in time
O(n log n). Now we prove that our algorithms for these problems are in
fact optimal.
We start with the two whose lower bound is easily obtained from the
problem SORTING: EUCLIDEAN-MINIMUM-SPANNING-TREE (EMST)
and TRIANGULATION. For this, we rst prove a simple lemma.
Lemma 8.4.4 Let S be a set of n real numbers x1, x2, , xn. If S is given
in such a way that for each 1 k n, the number xk is companied by an
index Ik such that xIk is the smallest number in S that is larger than xk .
Then the set S can be sorted in linear time.
proof. To sort the set S , we rst scan the set S to nd the minimum
number xk1 in S . Since xk1 is companied by an index k2 = Ik1 such that xk2
is the smallest number in S that is larger than xk1 , xk2 must be the second
smallest number in S . Moreover, since we know the index k2 , we can get
xk2 and put it immediately after xk1 in constant time. In general, suppose
164 LOWER BOUNDS
we have obtained xki that is the ith smallest number in S . Then since xki is
companied by an index ki+1 = Iki such that xki+1 is the smallest number in
S that is larger than xki , xki+1 is the (i + 1)st smallest number in S , and we
can get xki+1 and put it immediately after xki in constant time. It is clear
that after n ? 1 such iterations, we reach the largest number in S and obtain
a sorted list of the numbers in S . Since each iteration takes only constant
time, we conclude that the set S is sorted in linear time.
We rst consider the problem EMST.
Lemma 8.4.5 SORTING can be reduced to EMST in linear time.
proof. Given a set S of n real numbers x1, x2 , , xn , which is an
instance of SORTING, we construct an instance S 0 of EMST which is the
set of n points
(x1; 0); (x2; 0); ; (xn; 0)
in the plane. Moreover, for each 1 i n, we attach an index i to the point
(xi ; 0). It is easy to see that the solution to EMST on the input S 0 is a chain
A0 of n ? 1 segments in the plane, such that a segment (xi; 0)(xj; 0) is in A0
if and only if the number xj is the smallest number in S that is larger than
xi .
Now pass the chain A0 back to SORTING. For each segment (xi ; 0)(xj ; 0)
in A0, we construct a pair (xi ; j ) (remember that the index j is attached to
the point (xj ; 0)). Using these pairs, we can construct the sorted list of S in
linear time, by Lemma 8.4.4. This proves
SORTING /n EMST
This Lemma, together with Theorem 8.4.3 and Theorem 8.4.1 gives us
the following theorem.
the Euclidean minimum spanning tree for a set of n points in the plane runs
in time at least
(n log n).
Therefore, the algorithm presented in Section 6.4 that constructs the
Euclidean minimum spanning tree for sets of points in the plane is optimal.
Now we consider the problem TRIANGULATION.
Lemma 8.4.7 SORTING can be reduced to TRIANGULATION in linear
time.
proof. The proof is very similar to the proof of Lemma 8.4.5. Given a
set S of n real numbers x1, x2, , xn , we construct a set S 0 of n + 1 points
in the plane
q = (x1; 2); p1 = (x1; 0); p2 = (x2; 0); ; pn = (xn; 0)
It is easy to see that the set S 0 has a unique triangulation that consists of
the n segments qpi for 1 i n, and the n ? 1 segments pi pj where the
number xj is the smallest number in S that is larger than xi .
Now using the similar argument as the one we used in the proof of
Lemma 8.4.5, we conclude that we can construct the sorted list of S from
the triangulation of S 0 in linear time.
the triangulation for a set of n points in the plane runs in time at least
(n log n).
Thus the problem TRIANGULATION also has an optimal algorithm,
which was presented in Section 6.3.
A simple generalization of the problem TRIANGULATION is the prob-
lem CONSTRAINED-TRIANGULATION, as introduced in Section 3.4. A
lower bound for the CONSTRAINED-TRIANGULATION can be easily ob-
tained from the lower bound of TRIANGULATION.
Theorem 8.4.9 Any bounded order algebraic decision tree solving the prob-
lem CONSTRAINED TRIANGULATION runs in time at least
(n log n).
proof. It is easy to prove that
TRIANGULATION /n CONSTRAINED TRIANGULATION
In fact, every instance of the problem TRIANGULATION, which is a
set S of n points in the plane, is an instance G = (S; ) of the problem
CONSTRAINED TRIANGULATION, in which the set of segments is empty.
Since the problem TRIANGULATION has a lower bound
(n log n),
by Theorem 8.4.1, the problem CONSTRAINED TRIANGULATION has a
lower bound
(n log n).
166 LOWER BOUNDS
To derive lower bounds for the problems CLOSEST-PAIR and ALL-
NEAREST-NEIGHBORS, we use the lower bound for the problem
ELEMENT-UNIQUENESS, derived in the last section.
Theorem 8.4.10 Any bounded order algebraic decision tree nding the clos-
est pair for a set of n points in the plane runs in time at least
(n log n).
proof. We prove that
ELEMENT-UNIQUENESS /n CLOSEST-PAIR
Given a set S of n real numbers x1 , , xn , we construct an instance for
CLOSEST-PAIR:
(x1; 0); (x2; 0); ; (xn; 0)
which is a set S 0 of n points in the plane. Clearly, all elements of S are
distinct if and only if the closest pair in S 0 does not consist of two identi-
cal points. So the problem ELEMENT-UNIQUENESS is reducible to the
problem CLOSEST-PAIR in linear time. Now the theorem follows from
Theorem 8.3.1 and Theorem 8.4.1.
Since it is straightforward that
CLOSEST-PAIR /n ALL-NEAREST-NEIGHBORS
by Theorem 8.4.10 and Theorem 8.4.1, we also obtain the following theorem.
Theorem 8.4.11 Any bounded order algebraic decision tree nding the
nearest neighbor for each point of a set of n points in the plane runs in
time at least
(n log n).
Thus the algorithms we derived in Section 6.2 for the problems
CLOSEST-PAIR and ALL-NEAREST-NEIGHBORS are also optimal.
To discuss the lower bound on the time complexity of the problem
MAXIMUM-EMPTY-CIRCLE, we use the
(n log n) lower bound for the
problem UNIFORM-GAP, derived in the last section.
a maximum empty circle for a set of n planar points runs in time at least
(n log n).
proof. We show that

UNIFORM-GAP /n MAXIMUM-EMPTY-CIRCLE
Given a set S of n real numbers x1 , , xn and another real number ,
which is an instance of the problem UNIFORM-GAP, we construct a set S 0
of n planar points
(x1; 0); (x2; 0); ; (xn; 0)
which is an instance of the problem MAXIMUM-EMPTY-CIRCLE.
Note that the diameter d of the maximum empty circle of S 0, which is
part of the solution of MAXIMUM-EMPTY-CIRCLE on the input S 0 , is
the maximum distance of two consecutive numbers in the set S . Therefore,
if d 6= , the S is not a YES-instance of UNIFORM-GAP. However, d =
does not imply that S is a YES-instance of UNIFORM-GAP since some
consecutive numbers could have distance less than . To make sure that
every pair of consecutive numbers has distance exactly , we scan the set
S to nd the maximum number xmax and the minimum number xmin in S .
Now note that S is a YES-instance of UNIFORM-GAP if and only if
d= and xmax ? xmin = (n ? 1)
Therefore, given the diameter d of the maximum empty circle of S 0, a cor-
rect solution to UNIFORM-GAP on the input S can be obtained in lin-
ear time. This proves that UNIFORM-GAP is reducible to MAXIMUM-
EMPTY-CIRCLE in linear time.
By Theorem 8.3.2 and Theorem 8.4.1, a lower bound on the time com-
plexity of the problem MAXIMUM-EMPTY-CIRCLE is
(n log n).
Therefore, our algorithm in Section 6.5 for nding the maximum empty
circle given a set of points in the plane is also optimal.
We have presented an O(n log n) time algorithm for the FARTHEST-
PAIR problem in Section 3.3. We now prove that this algorithm is op-
timal by showing a lower bound on the time complexity of the problem.
For this, we make use of the O(n log n) lower bound for the problem SET-
DISJOINTNESS.
problem FARTHEST-PAIR runs in time at least
(n log n).
168 LOWER BOUNDS
proof. We prove
SET-DISJOINTNESS /n FARTHEST-PAIR
Given an instance I = (X; Y ) of the problem SET-DISJOINTNESS, we
transform I into an instance of FARTHEST-PAIR as follows. Without loss
of generality, suppose that all numbers in X and Y are positive. (Otherwise,
we scan the sets X and Y to nd the smallest number z in X [ Y , then
add the number z + 1 to each number in X and in Y .) Now nd the largest
number zmax in X [ Y . Convert each number xi in the set X into a point on
xi , and convert each
the unit circle in the plane which has a polar angle zmax
number yj in the set Y into a point on the unit circle in the plane which
yj + . Intuitively, we transform all numbers in the
has a polar angle zmax
set X into points in the rst and second quadrants of the unit circle in the
plane, while transform all numbers in the set Y into points in the third and
fourth quadrants of the unit circle. Such a transformation gives us a set S
of 2n planar points. It is easy to see that the diameter of S is 2 if and only
if the intersection of X and Y is not empty. This proves that the problem
SET-DISJOINTNESS can be reduced to the problem FARTHEST-PAIR in
linear time.
By Theorem 8.3.3, the problem SET-DISJOINTNESS has a lower bound
(n log n). Now by Theorem 8.4.1, the problem FARTHEST-PAIR also has
a lower bound
(n log n) on its time complexity.
8.5 A remark on our model

Here is an interesting story that surprised many researchers in Algorithm
Analysis.
Consider the following problem.
MAXIMUM-GAP
Output: The maximum distance between two consecutive numbers in S .
It is easily seen from the proof of Theorem 8.4.12 that
UNIFORM-GAP /n MAXIMUM-GAP
A REMARK 169
Therefore, any bounded order algebraic decision tree that solves the problem
MAXIMUM-GAP runs in time at least
(n log n).
However, it is surprising that if the \ oor function" b c is allowed in our
computational model, then the problem MAXIMUM-GAP can be solved in
linear time! We describe the algorithm as follows.
Given a set S of n real numbers x1 , x2 , , xn , we begin by nding the
maximum number xmax and the minimum number xmin in S . This can be
done in linear time by scanning the set S . Next, we divide the interval [xmin,
xmax] into (n ? 1) \buckets"
[xmin; xmin + ); [xmin + ; xmin + 2 ); [xmin + 2; xmin + 3 ); ;
[xmin + (n ? 3); xmin + (n ? 2) ); [xmin + (n ? 2); xmax]
where = (xmax ? xmin)=(n ? 1). Call the bucket [xmin + (n ? 2); xmax]
the (n ? 1)st bucket Bn?1 , and call the bucket [xmin + (k ? 1); xmin + k )
the kth bucket Bk , for 1 k n ? 2. Now for each xi of the n ? 2
numbers in S ? fxmin; xmaxg, determine which bucket the number xi should
belong to. The number xi belongs to the kth bucket Bk if and only if
b(xi ? xmin)=c = k ? 1. Therefore, each number in S ? fxmin; xmaxg can be
distributed to the proper bucket in constant time, and consequently, the n ? 2
numbers in S ? fxmin; xmaxg can be distributed to proper buckets in linear
time if the buckets are implemented by linked lists. Now for each bucket
Bk , compute the minimum number x(min k) and the maximum number x(k) in
max
Bk . If a bucket Bk contains one number, return the unique number as both
k) , x(k) , and if a bucket is empty, return nothing. Since for each bucket
x(min max
Bk , the numbers x(mink) and x(k) can be computed in the time proportional
max
k) and x(k) , 1 k n ? 1 can be
to the size of the bucket Bk , all these x(min max
computed in time linear to n. Now construct a list L
x(1) (2) (2) (n?1) (n?1)
min; xmax; xmin; xmax; ; xmin ; xmax
L: (1)
(Note that some numbers above may not appear in the list L if the corre-
sponding bucket is empty.) The list L can be easily constructed in linear
time from the n ? 1 buckets.
Since there are n ? 1 buckets and only n ? 2 numbers in S ?fxmin; xmaxg,
at least one bucket is empty. Therefore, the maximum distance between a
pair of consecutive numbers in S is at least the length of a bucket. This
implies that no two consecutive numbers contained in the same bucket can
make the maximum distance. Thus the maximum distance must be made
170 LOWER BOUNDS
k) and x = x(h) for
by a pair of the numbers (xi ; xj ) that are either xi = x(max j min
some k and h (where all buckets Bk+1 , , Bh?1 are empty), or xi = xmin
and xj = x(mink) (where all buckets B , , B (k)
1 k?1 are empty), or xi = xmax
and xj = xmax (where all buckets B(k+1) , , B(n?1) are empty). Moreover,
all these pairs can be found in linear time by scanning the list L. Therefore,
the maximum distance between pairs of consecutive numbers in S can be
computed in linear time.
In the following, we give an even simpler linear time algorithm to solve
the problem UNIFORM -GAP2 . In this algorithm, we even do not require
oor function. The only non-algebraic operation we need is a test if a given
real number is an integer. Note that with the oor function, the test \Is r
an integer" can be easily done in constant time.
Algorithm MAGIC
Given: A set S = { x_1, x_2, ..., x_n } of real numbers.

Question: Is the distance between any two consecutive
numbers of S uniformly equal to epsilon?
{In the following algorithm, A is an array of size n, which

is initialized to empty.}
BEGIN
1. Find the minimum number x_min and the maximum number
x_max in S;
2. Let epsilon = (x_max - x_min)/(n-1);
3. For i = 1 to n do BEGIN
3.1 Let k = (x_i - x_min)/epsilon + 1;
3.2 IF k is not an integer OR A[k] is not empty THEN
STOP with an answer NO
3.3 ELSE
put x_i in the array element A[k];
END;
4. STOP with an answer YES;
END.
The above algorithm obviously runs in linear time. To see the correct-
ness, suppose that the algorithm stops at Step 4. Then if a number x is in
2 The author was informed of this algorithm by Roger B. Dubbs III.
EXERCISES 171
A[k], then the value of x must be xmin + (k ? 1). Moreover, no array element
of A holds more than one number. Consequently, every array element of A
holds exactly one number from the set S , and these numbers are xmin + i ,
for i = 0; 1; ; n ? 1. Therefore, the set S should be a YES-instance of the
problem UNIFORM - GAP.
On the other hand, if the algorithm stops at Step 3.2, then either S is
not uniformly distributed (otherwise all values (x ? xmin)= + 1 should be
integral) or the set S contains two identical numbers. In the latter case, the
set S again cannot be a YES-instance of the problem UNIFORM -GAP.
The examples bring up an interesting point: there are certain very com-
mon operations not included in the algebraic decision tree model that allow
us to do things that are not possible in the algebraic decision tree model.
The oor function and the integral testing are examples of this kind of op-
erations. Note that these examples imply that the oor operation and the
integral testing cannot be performed in constant time in the algebraic deci-
sion tree model.
8.6 Exercises
1. Let P be an arbitrary non-trivial problem (i.e., it has YES-instances
as well as NO-instances). Show that the problem MAX-ELEMENT
(given a set of numbers, nd the maximum) is linear time reducible to
P.
2. Use Ben-or's technique directly to prove that the following problem
has a lower bound
(n log n) on the time complexity.
SET-DISJOINTNESS
Given two sets X = fx1; ; xn g and Y = fy1; ; yn g of real numbers,
are they disjoint, i.e., X \ Y = ?
3. Prove that the problems STAR-POLYGON, INTERSECTION-OF-
HALF-PLANE, and MONOTON-POLYGON take
(n log n) time in
the algebraic decision tree model.
4. Prove that the problem VORONOI-DIAGRAM takes
(n log n) time
in the algebraic decision tree model.
5. Design an optimal algorithm that constructs convex hulls for sets of
points in 3-dimensional Euclidean space.
172 LOWER BOUNDS
6. Show that the problem SECOND CLOSEST PAIR takes
(n log n)
time in the algebraic decision tree model.
7. Given two sets A and B of points in the plane, each containing N
elements, nd the two closest points, one in A and the other in B .
Show that this problem requires
(N log N ) opertations (Hint: what
problem can we reduce to this problem?).
8. Give an optimal algorithm that, given a set of 2N points, half with pos-
itive x-coordinates, half with negative x-coordinates, nds the closest
pair with one member of the pair in each half.
9. Prove that the following problem has an
(N log N ) lower bound:
Given N points in the plane, construct a regular PSLG whose vertices
are these N points.
10. Given a PSLG G, design an algorithm regularizing G in time
O(n log n). Provide sucient details for the implementation of your
algorithm. (This does not mean you give a PASCAL or C program.
Instead, you should provide sucient detail for the data structure you
use to suppose your operations.)
11. Prove that your algorithm for the last question is optimal.
12. Prove that the following problem has a lower bound
(n log n):
Given a PSLG G, add edges to G so that the resulting graph is a PSLG
G0 such that each region of G0 is a simple polygon.
(Hint: You can suppose Chazelle's result.)
13. Prove that the following problem requires
(n log n) time in algebraic
decision tree models: given n points and n lines in the plane, determine
whether any point lies on any line.
14. Given a set of n points in the plane, let h denote the number of vertices
that lie on its convex hull. Show that any algorithm for computing the
convex hull must require
(n log h) time in the algebraic decision tree
model.
15. Given a convex n-gon, show that determining whether a query point
lies inside or outside this n-gon takes
(log n) time in the algebraic
decision tree model.
EXERCISES 173
16. Given a set S of n points in the plane, show that the problem of
nding the minimum area rectangle that contains these points requires

(n log n) time in the algebraic decision tree model.
17. Can you construct another example that requires
(n log n) time in
the algebraic decision tree model but is solvable in linear time?
174 LOWER BOUNDS
Chapter 9
Geometric Transformations
In this chapter, we will discuss an important technique in computational
geometry: The geometric transformations. We will introduce the method by
showing how this method is applied to solve geometric intersection problems,
such as half plane intersection and convex polygon intersection. We will also
apply the method to nd the smallest area triangles. We will see that the
geometric transformation techniques enable us to convert these geometric
problems into more familiar problems we have discussed.
Geometric transformations have their roots in the mathematics of the
early nineteenth century [6]. Their applications to problems of computing
dates back to the concept of primal and dual problems in the study of linear
programming (see, for example, [21]).
Brown [7] gives a systematic treatment of transformations and their ap-
plications to problems of computational geometry. Since his dissertation,
these methods have found vast application.
Typically, transformations change geometric objets into other geomet-
ric objects (for example, take points into lines) while preserving relations
which held between the original objects (for example, order or whether they
intersected). A number of geometric problems are best solved through the
use of transformations. The standard scheme is to transform the objects
under consideration, solve a simpler problem on the transformed objects,
and then use that solution to solve the original problem. No single transfor-
mation applies in all cases; a number of dierent transformations have been
used eectively. Here, we describe two commonly used transformations and
demonstrate their applications.
175
176 GEOMETRIC TRANSFORMATIONS
9.1 Mathematical background
Let l be a straight line on the Euclidean plane. If l is a vertical line, then l
can be characterized by an equation
x=a
if the line l intersects the x-axis at the point (a; 0). On the other hand, if
l is not a vertical line, let be the angle from the positive direction to the
line l,1 then l can be characterized by the equation
y = ax + b
If a = tan and the line l intersects the y -axis at the point (0; b). We will
call the direction of the line l, and call the value a = tan the slope of the
line l. The slope of a straight line l is denoted by slope(l).
The domain of all of our two-dimensional transformations will be the
projective plane, which is an enhanced version of the Euclidean plane in
which each pair of lines intersects. The projective plane contains all points
of the Euclidean plane (call them the proper points). We introduce a set of
improper points with one point Pa associated with every slope a in the plane.
Two parallel lines, then, intersect at that improper point indicated by the
slope of the parallel lines (this can be thought of as a point at innity). All
improper points are considered to lie on the same line: the improper line
or the line at innity. Thus, any two lines in the projective plane intersect
at exactly one point: two nonparallel proper lines intersect at a proper
point (i.e., one of the Euclidean plane); two parallel proper lines intersect
at the improper point bearing the same slope; and a proper line intersects
the improper line at the improper point dening the slope of the proper
line. Likewise, between every two points passes exactly one line: There is a
proper line passing through every pair of proper points; a proper line passes
through a given improper point and a given proper point; and the improper
line passes through any two improper points.
In general, the actual algorithms used to solve problems rely solely on
the Euclidean geometry. Therefore, although all the transformations will
map the projective plane onto itself, we will wish to choose a transformation
which maps the objects under consideration to \proper" objects. Thus, the
1 In this case, we always suppose that ?=2 < =2. That is, we always suppose
that the direction of the straight line l goes to the innity either in the rst quadrant or
in the fourth quadrant.
HALF PLANE INTERSECTION 177
l1
l2 l4
l3
Figure 9.1: The half plane H4 is redundant
parameters of the original problem will dictate which transformations are

appropriate. Throughout this chapter, we will use the following notation:
The images of a geometric object G, which can be a point p, a line l, or a
polygon P , etc., under a transformation B will be denoted by B (G).
9.2 Half plane intersections

We introduce the rst geometric transformation through the following ex-
ample.
Given a set of n lower half planes
Hi : y a i x + bi i = 1; ; n
Let P be the intersection of these n lower half planes. It is easy to see that
P is an unbounded convex area with an upper boundary
(ei1 ei2 eir )
which is a polygonal chain from left to right, where ei1 and eir are semi-
innite rays, and eij for 2 j r ? 1 are straight line segments, such that
if traveling along the chain from ei1 to eir , we always make right turn.
Not every lower half plane is useful for the intersection P . For example,
in Figure 9.1 the lower half plane H4 dened by the line l4 is not useful for
the intersection P since the intersection P is entirely contained in the lower
half plane H4 .
We say that a lower half plane Hk : y ak x + bk is redundant to the
intersection P if the intersection P is entirely contained in the half plane
Hk . This simply implies \ \
Hi = Hi
1in i6=k
Now given n lower half planes Hi , i = 1; ; n, and let P be their inter-
section. How do we nd all redundant half planes to the intersection? For
this, we rst discuss the property of a redundant half plane.
Suppose that H : y ax + b is a lower half plane. We call the line
l : y = ax + b the boundary line of the lower half plane H . We also say
that the lower half plane H is dened by the straight line l : y = ax + b .
Lemma 9.2.1 Given a set S of n lower half planes Hi dened by the straight
lines li , i = 1; ; n. A lower half plane Hk is redundant if and only if there
are two lower half planes Hc and Hd in S such that
slope(lc) slope(lk ) slope(ld )
and the intersecting point of lc and ld is below the line lk .
proof. Suppose that the lower half plane Hk is redundant, then the
intersection P of the n lower half planes in S is entirely below the line lk .
Let
= (ei1 ei2 eir )
be the boundary polygonal chain of P from left to right, where ei1 and eir
are semi-innite rays, and eij for 2 j r ? 1 are straight line segments,
such that if traveling along the chain from ei1 to eir , we always make right
turn. Suppose that the edge eih is on the line lih for h = 1; ; r. We claim
slope(li1 ) slope(lk ) slope(lir )
In fact, if slope(li1 ) < slope(lk ) then since the starting point of the ray
ei1 is below the line lk , the ray ei1 must cross the line lk at some point,
contradicting the assumption that Hk is redundant. Similarly we can prove
that slope(lk ) slope(lir ). Since the chain makes only right turn when
we travel from ei1 to eir , the slopes of the sequence of lines
li1 ; li2 ; ; lir
are strictly decreasing. Thus there must be two consecutive lines lih and
lih+1 such that
slope(lih ) slope(lk ) slope(lih+1 )
Moreover, the intersecting point of the lines lih and lih+1 is the point on the
chain which is incident to the edges eih and eih+1 , thus must be below the
line lk .
Conversely, if there are two lines lc and ld such that
and the intersection point of lc and ld is below the line lk . Then clearly,
the intersection Hc \ Hd of the two lower half planes Hc and Hd is entirely
contained in the lower half plane Hk . Therefore,
\
P= Hi Hc \ Hd Hk
1in
That is, the lower half plane Hk is redundant to the intersection P .
By this lemma, a naive method of deciding the redundancy of a given
half plane Hk entails comparing its boundary line against all other pairs of
boundary lines in time O(n2). Finding all redundant lower half planes thus
takes time O(n3 ).
We use the technique of geometric transformations to design a more
ecient algorithm to nd redundant lower half planes.
Let us rst see what kinds of geometric properties are used for redundant
lower half planes. To show that a lower half plane H dened by a line
l : y = ax + b is redundant, we must show the existence of two lower
half planes Hc and Hd dened by the lines lc : y = ac x + bc and
ld : y = adx + bd such that
slope(lc ) slope(l) slope(ld )
and the intersecting point of lc and ld is below the line l. Therefore, if T
is a geometric transformation, then given a line l, we would like that the
parameter slope(l) is mapped to a parameter of the geometric object T (l)
such that the ordering of the slopes of lines is preserved. Moreover, let p
be a point and l be a line, then we want the relations \above" and \below"
between p and l are also preserved for the geometric objects T (p) and T (l).
Now consider the following geometric transformation T1. Given a point
p : (a; b) in the Euclidean plane, the image T1(p) under the transformation
T1 is a straight line
T1(p) : y = ax + b
Now let l : y = x + be a line. Since each point l is mapped to
a line by the transformation T1, T1(l) is a collection of lines. However, all
these lines have a common intersecting point. In fact, let q0 = (x0 ; y0) be a
point on the line l, then we have
y0 = x0 +
Thus the image of q0 under T1 is the line
T1(q0 ) : y = x0 x + y0 = x0 x + (x0 + )
It is easy to see that the line T1(q0 ) passes through the point (?; ). There-
fore, instead of regarding that the T1 (l) as a collection of lines, we regard
T1 (l) as a single point (?; ), and say that the transformation T1 maps a
line into a point.
Note that the above process of deriving the image T1(l) of the line l
from the images of the points on the line l can be reversed. That is, since
we have dened the image of a point p = (a; b) under T1 to be the line
T1 (p) : y = ax + b , we can derive that the image of a line l : y = x +
under T1 is a point T1 (l) = (?; ). Alternatively, if we start by dening
that the image of a line l : y = x + is the point T1(l) = (?; ),
then given a point p = (a; b), we regard p as a collection of all lines passing
through the point p = (a; b). Any line l0 in this collection can be represented
by an equation
l0 : y = x + (b ? a)
where can be any real number. Thus the image of l0 under T1 is a point
(?; b ? a), which is a point on the line y = ax + b. Thus the image of the
point p = (a; b) under T1 is the line
T1(p) : y = ax + b
This discussion shows that the intersection relation between a point and
a line is preserved under the transformation. A more precise description is
given in the following observation.
Observation 1.
Two points p1 and p2 are on the same line l if and only if the two lines
T1 (p1) and T1(p2 ) intersect at the point T1(l).
Observation 2.
Two lines l1 and l2 intersect at a point p if and only if the two points
T1 (l1) and T1(l2) are on the same line T1(p).
The denition of the transformation T1 has only been given for the \nor-
mal points", which are the points in the Euclidean plane, and for the \normal
lines", which are of the form y = ax + b that is not a vertical line. We need
to extend the denition to the improper points in the projective plane and
to vertical lines. Using the idea of regarding a vertical line l as the collection
of points on the line, and regarding an improper point P as the collection
of the parallel lines of slope , we can easily see that the image of a vertical
line x = a is the improper point Pa and the image of an improper point P
is the vertical line x = ?. We leave the detail derivation of these to the
reader.
We now show that the ordering of the slope of lines, as well as the
relations \above" and \below" of points and lines, are preserved under the
transformation T1. Let
l1 : y = a 1 x + b 1 and l2 : y = a 2 x + b 2
be two lines with the slopes a1 and a2, respectively. Then after the trans-
formation T1 , the line l1 becomes a point (?a1 ; b1) while the line l2 becomes
a point (?a2 ; b2). Therefore, if we denote by x(p) the x-coordinate of the
point p, then we have
Observation 3.
The slope of line l1 is greater than the slope of line l2 if and only if the
x-coordinate of the point T1(l1) is less than the x-coordinate of the point
T1 (l2). That is
slope(l1) > slope(l2) i x(T1(l1)) < x(T1(l2))
Now let p = (a; b) be a point and let l : y = x + be a line such

that p is below the line l. Thus b < a + . After the transformation T1 ,
the point p becomes a line T1(p) : y = ax + b while the line l becomes a
point T1(l) = (?; ). Since > a(?) + b, the point T1 (l) is above the line
T1 (p). This gives us the third observation.
Observation 4.
A point p is below a line l if and only if the line T1(p) is below the point
T1 (l).
Now we return back to the problem of deciding redundant lower half
planes. Given a set A of n points in the plane, by the lower hull of A we
denote the partial chain on the convex hull CH(A) which is from the point
of the minimum x-coordinate in A to the point of maximum x-coordinate
in A and bounds the convex hull CH(A) from below. Using the modied
Graham scan algorithm, we know that the lower hull of the set A can be
constructed in time O(n log n) (see Section 2.2.)
Now given a set S of n lower half planes Hi , where the lower half plane
Hi is dened by a straight lines li , for i = 1; ; n. Let P be the intersection
of these n lower half planes. We rst transform each line li in S by the
transformation T1 into a point T1(li ). Let T1(S ) be the set of images of the
lines in S under T1. T1(S ) is a set of n planar points.
Theorem 9.2.2 A lower half plane Hk in S is redundant to P if and only
if the point T1(lk ) is not on the lower hull of CH(T1(S )).
proof. If the lower half plane Hk in S is redundant, By Lemma 9.2.1,
there are two lower half planes Hc and Hd in S such that
slope(lc) slope(lk) slope(ld)
and the intersecting point p of lc and ld is below the line lk . By Observation 3,
we have
x(T1(lc)) x(T1(lk )) x(T1(ld ))
Moreover, the point T1(lk ) is above the line T1 (p), by Observation 4. Finally,
by Observation 2, the two points T1(lc ) and T1(ld) are on the line T1(p), thus
the point T (lk ) is above the line segment T1(lc )T1(ld). That is, the point
T1 (lk ) cannot be on the lower hull of T1 (S ).
Conversely, suppose that the point T1(lk ) is not on the lower hull of
T1 (S ), then there are two points T1(lc ) and T1(ld ) in the set T1(S ) such that
the point T1(lk ) is above the line segment T1 (lc)T1(ld ). So we have
x(T1(lc)) x(T1(lk )) x(T1(ld ))
By Observation 3, we have
Moreover, let l be the line on which the line segment T1(lc )T1(ld) lies, then
by Observation 2, the line l is the image of the intersecting point p of the
lines lc and ld under T1. By Observation 4, the intersecting point p is below
the line lk . Now by Lemma 9.2.1, the line lk is redundant to the intersection
P.
Now it is straightforward to derive an algorithm nding the redundant
lower half planes given a set of lower half planes.
Algorithm FIND-REDUNDANCY (S)
f Given a set S of n lower half planes Hi, where Hi is dened by a line
li , for i = 1; ; n, nd all redundant half planes. g
begin
1. Using the transformation T1 to transform each line li into a point
T1(li); Let the set of the images of lines in S under T1 be T1(S );
2. Construct the lower hull LH (T1(S )) of T1(S );
3. For k = 1; ; n, a lower half plane Hk is redundant if and only if the
point T1(lk ) is not on the lower hull LH (T1(S )).
end
The algorithm is correct according to Theorem 9.2.2. Step 2 in the
algorithm takes time O(n log n) by our discussion in Section 2.2. All other
steps trivially take linear time. So the time complexity of the algorithm is
O(n log n).
With the algorithm FIND-REDUNDANCY, it is easy to design an algo-
rithm computing the intersection of half planes.
HALF-PLANE-INTERSECTION
Given n + m half planes
y ai x + bi i = 1; ; n
y cj x + dj j = 1; ; m
in the plane, compute the intersection of them.
The problem can be split into two problems as follows: We consider the
intersection P1 of the n lower half planes:
y ai x + bi i = 1; ; n
and the intersection P2 of the m upper half planes:
y cj x + dj j = 1; ; m
Then the intersection of the n + m half planes is the intersection of P1 and
P2 .
The two areas P1 and P2 are unbounded polygonal areas, and both of
them are convex. It is a simple exercise to show that the intersection of the
two polygonal areas P1 and P2 can be computed in time O(n1 + n2 ), where
ni , i = 1; 2, is the number of boundary edges of the polygonal area Pi .
Therefore, the problem HALF-PLANE-INTERSECTION can be re-
duced to computing the intersection of lower half planes and computing
the intersection of upper half planes. Since the two problems are symmetric,
we will concentrate on the problem of intersection of lower half planes.
LOWER-HALF-PLANE-INTERSECTION
Given n lower half planes
Hi : y ai x + bi i = 1; ; n
in the plane, compute the intersection P1 of them.
A half plane that is not redundant is called a useful half plane of the
intersection P1 . Clearly, a half plane Hk : y ak x + bk is useful to the
intersection P1 if the straight line y = ak x + bk contributes a boundary
edge to the polygonal area P1 . Let
Hik : y aik x + bik k = 1; ; r
be the set of useful half planes to the intersection P1 such that the boundary
of the polygonal area P1 is formed by a polygonal chain
(ei1 ei2 eir )
from left to right, where the edge eik on the chain is contributed by the
straight line
lik : y = aik x + bik
SMALLEST AREA TRIANGLE 185
for k = 1; ; r. Since P1 is a convex polygonal area and is below its bound-
ary, the slope of the lines lik must be strictly decreasing. This observation
gives us immediately an algorithm to compute the intersection P1 .
Algorithm LOWER-PLANE-INTERSECTION
f Given the set S of n lower half planes, compute their intersection. g
begin
1. Eliminate all redundant lower half planes,
2. Sort the boundary lines of the useful half planes by their slopes in de-
creasing ordering. Let the sorted list of the lines be
fli1 ; li2 ; ; lir g
3. For k = 1 to r ? 1, compute the intersecting point pk of the lines lik
and lik+1 .
4. The polygonal chain
fli1 p1p2 pr?1lir g
is the boundary chain of the intersection P1 .
end
Step 1 takes time O(n log n) using the algorithm FIND-REDUNDANCY.
Step 2 takes also time O(n log n) by any optimal sorting algorithm. The
remaining of the algorithm takes linear time. Therefore, the above algorithm
runs in time O(n log n). By our comments before, the intersection of n half
planes can also be computed in time O(n log n). It is easy to see that this
is also a lower bound for the problem, since the problem SORTING can be
easily reduced to this problem. Thus we have
Theorem 9.2.3 The problem HALF-PLANE-INTERSECTION can be
solved by an optimal algorithm in O(n log n) time.
Finally we remark that our algorithm for using a geometric transfor-
mation to solve the problem HALF-PLANE-INTERSECTION consisted of
three parts: We rst identied the geometric techniques we might use (here
is eliminating redundant half planes). Next, we identied the invariants re-
quired by a transformation (here are the \above"/\below" relation and the
ordering of slopes). Finally, we found an appropriate transformation and
solved the problem. This is a classic example of how geometric transforma-
tions are used.
9.3 The smallest area triangle
We give another example of the applications of the geometric transformation
T1 . Consider the following problem.
THE-SMALLEST-TRIANGLE
Given a set S of n points in the plane, nd the smallest area triangle
whose three vertices are points in S .
A brute force way to solve this problem is to compute, for every three
points in S , the area of the triangle formed by these three points, and then
pick? the
one with the smallest area. This algorithm takes time proportional
n
to 3 = O(n3).
A variation of the above algorithm is that given a pair of points pi and
pj in S , compute the distance d(k; i; j ) from a point pk to the line li;j passing
through the points pi and pj , where pk is any point picked from S ?fpi ; pj g.
Since the area of the triangle formed by pi , pj , and pk is half of the product
d(k; i; j ) jpipj j, this will give us the areas of all triangles one of whose edge
is the segment pi pj . If we do this for every pair of points in S , we will
obtain the areas of all triangles formed by points in S , thus pick ? the one
with smallest area. The time complexity of this variation is O( n2 (n ? 1)),
which is again O(n3 ).
Denition Let p be a point and l be a line. The vertical distance, denoted
dv (p; l), from p to l is the distance from the point p to the intersecting point
of the line l and the vertical line passing through the point p.
Note that the vertical distance from a point p to a line l is in general
dierent from the distance from the point to the line, which is the distance
from the point p to the intersecting point of the line l and the line which
passes through p and is perpendicular to the line l.
Let pk , pi , and pj be three points in S . We denote by dv (k; i; j ) the
vertical distance from the point pk to the line li;j passing through the points
pi and pj . For simplicity, sometime we also call dv (k; i; j ) the vertical distance
from the point pk to the segment pi pj .
Lemma 9.3.1 Fix a pair of points pi and pj in the set S . Let li;j be the
line passing through the points pi and pj . Then a point pk in S ? fpi ; pj g
lv
l i,j
p
k
p
j
p
i
θ
Figure 9.2: The vertical distance from a point to a line
has the smallest distance d(k; i; j ) from the line li;j if and only if pk has the
smallest vertical distance dv (k; i; j ) from the line li;j .
proof. Let lv be the vertical line passing through the point pk which
intersects the line li;j at a point q . Let be the angle between the lines li;j
and lv . By the denition, the vertical distance dv (k; i; j ) from pk to li;j is the
length of the line segment pk q . Moreover, it is easy to see that the distance
d(k; i; j ) from pk to li;j is equal to jpk qj sin . See Figure 9.2. Thus, the
vertical distance from pk to li;j is proportional to the distance from pk to
li;j . The lemma follows immediately.
Therefore, to nd the smallest area triangle, for each pair of points pi
and pj in S , we only need to consider such a point pk in S ? fpi ; pj g such
that the vertical distance dv (k; i; j ) is the shortest. But how this observation
helps us?
We rst apply the transformation T1 on the set S of planar points. We
know that a point pk in S is mapped under T1 to a line T1(pk ) while a line
li;j passing through two points pi and pj in S is mapped under T1 to the
intersecting point T1 (li;j ) of the lines T1(pi ) and T1 (pj ). A nice property
of the transformation is that the vertical distance is preserved under the
transformation, as shown by the following lemma.2
Lemma 9.3.2 The vertical distance dv (pk; li;j ) from the point pk to the line
li;j is equal to the vertical distance dv (T1(li;j ); T1(pk )) from the point T1(li;j )
to the line T1(pk )
dv (pk ; li;j ) = dv (T1(li;j ); T1(pk ))
proof. The proof is straightforward through the calculations using basic

formulas in analytical geometry. Suppose that the coordinates of pi, pj , and
pk are
pi = (ai ; bi) pj = (aj ; bj ) pk = (ak ; bk )
Then the line li;j has the equation
? bj x + aibj ? aj bi
li;j : y = abi ?
i a ja ?a i j
Under the transformation T1, they are mapped to the lines T1(pi), T1 (pj )
and T1(pk ):
T1 (pi) : y = ai x + bi T1 (pj ) : y = aj x + bj T1(pk ) : y = ak x + bk
and the point
T1 (li;j ) = (? abi ? bj ai bj ? aj bi
?a ; a ?a )
i j i j
The intersecting point of the line li;j and the vertical line passing through
the point pk is
? bj a + aibj ? aj bi )
(ak ; abi ? a k a ?a
i j i j
Thus the vertical distance from the point to the line li;j is the absolute
pk
value of the following number
bi ? bj a + ai bj ? aj bi ? b = (aibj + aj bk + ak bi) ? (aibk + aj bi + ak bj )
ai ? aj k ai ? aj k ai ? a j
Similarly, the intersecting point of the line T1 (pk ) and the vertical line
passing through the point T1(li;j ) is
? bj ; ?a bi ? bj + b )
(? abi ? ka ? a k
i aj i j
2 Without loss of generality, we suppose that no two points in the set S have the same
x-coordinate. If this condition is not satised, we slightly rotate the coordinate system.
Thus the vertical distance from the point T1 (li;j ) to the line T1(pk ) is the
absolute value of the following number
ai bj ? aj bi ? (?a bi ? bj + b ) = (ai bj + aj bk + ak bi ) ? (ai bk + aj bi + ak bj )
ai ? a j ka k
i ? aj ai ? aj
This proves the lemma.
But why this lemma helps? Let us rst transform each point pi in the
set S under T1 to a line T1(pi) for i = 1; ; n. Then we will obtain a set
T1 (S ) of n straight lines
T1(S ) = fT1(p1); T1(p2 ); ; T1(pn)g
The set T1(S ) of these n lines T1(pi), i = 1; ; n, forms a PSLG, if we regard
each intersecting point of a pair of lines in T1(S ) as a vertex. Let li;j be the
line passing through the points pi and pj in S . Note that to nd a point in S
which has the smallest vertical distance to the line li;j , we have to check each
vertex in S ?fpi ; pj g. However, to nd the line T1(pk ) in T1 (S ) such that the
point T1(li;j ) has the smallest vertical distance to T1(pk ), we only need to
check in T1(S ) the lines immediately above and immediately below the point
T1 (li;j ). Therefore, if we well organize the PSLG T1(S ), we can nd eciently
the line T1(pk ) in T1(S ) such that the vertical distance from the point T1(li;j )
to the line T1(pk ) is the smallest over all lines in T1(S ) ? fT1(pi); T1(pj )g.
By Lemma 9.3.1 and Lemma 9.3.2, the distance from the point pk to the
line li;j is the smallest over all points in S ? fpi ; pj g, which implies that the
triangle 4(pk pi pj ) has the smallest area over all triangles one of whose edge
is the segment pipj . For each pair of points pi and pj in the set S , perform
the above process, we obtain the smallest area triangle.
Now we discuss how to nd the lines closest to the point T1(li;j ) in T1 (S ).
We perform a topological sweeping on the PSLG T1(S ) from left to right by
a vertical line L. The lines of T1(S ) are stored in a 2-3 tree A in the ordering
of their intersecting points with the line L on L. Since T1(S ) contains exactly
n lines T1(pi ), i = 1; ; n, the number of leaves of the 2-3 tree A is n, thus
the depth of A is bounded by O(log n). Suppose that at some moment, the
line L moves to a vertex T1(li;j ) of T1 (S ) from left to right, then it is easy to
see that except for the two lines T1(pi ) and T1(pj ) that intersect at T1 (li;j ),
all other lines in T1 (S ) maintain their relative position with respect to each
other in the 2-3 tree A. On the other hand, the lines T1 (pi) and T1 (pj )
should exchange their positions in the 2-3 tree A. In other words, if the
line T1 (pi) is above the line T1(pj ) on the left of the point T1(li;j ), then the
line T1(pi ) should be below the line T1(pj ) on the right of the point T1 (li;j ),
and vice versa. Let the two lines that are immediately above and below the
vertex T1 (li;j ) in the PSLG T1(S ) be T1(pk ) and T1(ph ), respectively. Then
the lines T1(pk ) and T1(ph ) can be also accessed in time O(log n) from the
2-3 tree A. To nd the relative position of a vertex T1(li;j ) in the 2-3 tree A,
we do a search in the 2-3 tree A by the values of y -coordinate while xing
the x-coordinate of each line in A to the value of the x-coordinate of the
vertex T1(li;j ).
The following is the implementation of the above discussion, which nds
the smallest area triangle given a set S of points in the plane.
Algorithm SMALLEST-TRIANGLE (S)
f Given a set S of n planar points, nd the smallest area triangle whose
three vertices are points in S . g
begin
1. For each point pi in S , i = 1; ; n, construct the line T1(pi ).
2. For each pair of lines T1(pi ) and T1 (pj ) constructed in Step 1, i; j =
1; ; n, compute the intersecting vertex T1 (li;j ).
3. Sort all intersecting vertices T1(li;j ), i; j = 1; ; n in increasing x-
coordinate ordering. Let the sorted list be
fv1; v2; ; vmg
?
where m = n2 , and vi = (xi ; yi ), for i = 1; ; m.
4. Construct a 2-3 tree A whose leaves are the lines T1(pi ), i = 1; ; n,
ordered by the y -coordinates of their intersecting points with the vertical
line x = x1 ? 1 .
5. For r = 1; ; m do the following
Suppose that the vertex vr is the intersecting vertex of the lines T1(pi )
and T1(pj ) and that the lines immediately above and below the vertex vr
are T1(pk ) and T1(ph ), respectively. Compute the areas of the triangles
4(pkpipj ) and 4(phpipj ). Exchange the positions of T1(pi) and T1(pj )
in the 2-3 tree A.
6. The triangle that is constructed in Step 5 and has the smallest area is
the the smallest area triangle.
end
One case we have ignored in the above algorithm is the case when there
are three lines T1(pi ), T1(pj ), and T1 (pk ) of T1(S ) intersecting at a com-
mon point. However, this means that the intersecting point T1(li;j ) of the
lines T1(pi ) and T1(pj ) has a zero vertical distance from the line T1 (pk ). By
Lemma 9.3.2, the point pk has a zero vertical distance from the line li;j . Con-
sequently, the three points pi , pj , and pk are co-linear and the smallest area
triangle of the set S has area zero. Therefore, whenever we nd that three
lines T1(pi ), T1(pj ), and T1(pk ) in T1 (S ) are co-linear, we stop immediately
and return the triple (pi ; pj ; pk ) as the smallest area triangle.
We analyze the algorithm.? Step 1 takes time O(n). Step 2 takes time
n
O(n ) and produces m = 2 = O(n2 ) intersecting vertices in T1 (S ). Thus
2
Step 3 takes time O(n2 log n) to sort the intersecting vertices constructed
in Step 2. Step 4 takes time O(n log n). For each vertex vr , Step 5 spends
O(log n) time to locate the position of the vertex vr in the 2-3 tree A, to
update the 2-3 tree A and to compute the areas of the two triangles, so
totally Step 5 takes time O(m log n) = O(n2 log n). Since for each vertex
vr , we construct at most two triangles, the number of triangles constructed
in Step 5 is bounded by O(m) = O(n2). Consequently, Step 6 takes time
O(n2 ). Therefore, the time complexity of the above algorithm is bounded
by O(n2 log n).
Since each line in the PSLG T1 (S ) corresponds to a point in S , the 2-3
tree A has exactly? n leaves. However, the space used to store the vertices vr ,
r = 1; ; m = n2 is
(n2 ). So the space used by the algorithm is O(n2 ).
Now we discuss how we can reduce the amount of space used by the
algorithm. As pointed out above, the O(n2 ) space is used to store the m
intersecting vertices of the lines T1(pi ), for i = 1; ; n. However, we do
not really need the whole sorted list of these intersecting vertices. What we
are really interested in is that at each stage which vertex is the next to the
current vertex vr . This next vertex must be the one that is on the right of
the current vertex vr and the closest to the vertical line passing through the
current vertex vr . Note that such a vertex must be the intersecting vertex
of two lines in T1 (S ) that are consecutive leaves in the current 2-3 tree A.
Therefore, if we keep a list B of the records for the intersecting vertices of
the consecutive leaves in the current 2-3 tree A that are on the right of the
current vertex vr (there are at most n ? 1 such intersecting vertices), then
the one in the list B that is the closest to the vertical line passing through
the current vertex vr must be the next vertex to be processed in Step 5 of
the above algorithm.
Therefore, instead of producing the whole list
v 1 ; v2 ; ; v m
of intersecting vertices of the lines T1(pi ), i = 1; ; n, we use a 2-3 tree
B to store the intersecting vertices of consecutive lines in the 2-3 tree A
that are on the right of the current vertex vr , sorted by their x-coordinates.
The number of leaves of the tree B is bounded by n ? 1. Suppose that the
current vertex is vr . To nd the next vertex, we simply nd the vertex vr+1
in the 2-3 tree B that has the smallest x-coordinate. Then the vertex vr is
deleted from the tree B . Note that after processing the vertex vr , adjacency
relations among only four lines in A can be changed. That is, suppose that
the vertex vr is the intersecting vertex of the lines T1 (pi) and T1 (pj ), that
the lines in T1(S ) immediately above and below the vertex vr are T1 (pk ) and
T1 (ph), respectively, and that before processing the vertex vr , the line T1(pi )
is above the line T1(pj ). Then after processing the vertex vr , the line T1 (pj )
is above the line T1(pi). Therefore, before processing the vertex vr , these
lines are in the ordering
T1(pk ); T1(pi ); T1(pj ); T1(ph )
in the 2-3 tree A, while after processing the vertex vr , the line ordering
becomes
T1(pk ); T1(pj ); T1(pi ); T1(ph )
Accordingly, the 2-3 tree B can be updated by deleting the intersecting
vertices of T1(pk ) and T1 (pi), and of T1 (pj ) and T1 (ph ), and inserting the
intersecting vertices of T1(pk ) and T1 (pj ), and of T1 (pi) and T1(ph ), if they are
on the right of the vertex vr . The intersecting vertices of T1 (pi) and T1 (pj )
is the vertex vr . Since the number of leaves of the 2-3 tree B is bounded by
n ? 1, each of the above operations can be done in time O(log n). Therefore,
processing a vertex vr in Step 5 of the algorithm takes time O(log n). And
the space now used by the algorithm, which is the sum of the 2-3 tree A and
the 2-3 tree B , is bounded by O(n).
This completes our description of an O(n2 log n) time and O(n) space
algorithm that solves the problem THE-SMALLEST-TRIANGLE.
Final Remark:
POLYGON INTERSECTIONS 193
If the area of the smallest area triangle is zero, then the three points
forming this triangle are co-linear. Consequently, the above algorithm can
be used to check if there exist three points that are co-linear in a given set of
n planar points. The algorithm we presented in this section is not the best
algorithm. The best algorithm we know for the problem THE-SMALLEST-
TRIANGLE is due to Edelsbrunner, O'Rourke, and Seidel, which runs in
time O(n2 ) and space O(n) [11]. Whereas, the only known lower bound
is
(n log n). In fact, even for checking whether there exist three co-linear
points, the only bounds that we know are O(n2) and
(n log n). Improving
the upper or lower bounds for either of these problems remains an extremely
tantalizing open problem in computational geometry.
9.4 Convex polygon intersections

Now we introduce the second geometric transformation T2 . Given a point
p = (a; b) in the plane, we dene the image of p under T2 to be the line
T2(p) : ax + by + 1 = 0
In a similar way as we did for the transformation T1, we discuss what is the
image of a line l : x + y + 1 = 0 . A point q0 = (a0 ; b0) on the line l
satises
x0 + y0 + 1 = 0
Thus y0 = (?= )x0 ? 1= , and the point q0 is mapped to the line
T2(q0) : x0 x + y0y + 1 = 0 or x0x + ((?=)x0 ? 1=)y + 1 = 0
It is easy to check that the line T2 (q0) passes through the point (; ). Thus
every point on the line l : x + y +1 is mapped to a line passing through
the point (; ). Thus we simply regard the image of the line l to be the
point (; ).
Again, the transformation T2 preserves the relation of intersection of a
point and a line. That is, a point p is on a line l if and only if the line T2(p)
contains the point T2 (l). More precisely, we have
Observation 1
Two points p and q are on the line l if and only if the two lines T2(p)
and T2(q ) intersect at the point T2 (l).
Observation 2
Two lines l1 and l2 intersect at a point p if and only if the two points
T2 (l1) and T2(l2) are on the same line T2(p).
Another nice property of the transformation T2 is that the distance of an
object from the origin is preserved. In fact, by analytical
p geometry, we know
that the distance of a point (a; b) from the origin is p a2 + b2 and the distance
of a line l : ax + by + 1 = 0 from the origin is 1= a2 + b2. Thus, points or
lines further from the origin are mapped to lines or points closer to the origin.
That the transformation T2 is also its own inverse (i.e., G = T2 (T2(G)) where
G is either a point or a line) also contributes to its usefulness. pMoreover, let
pp= (a; b) and q = (c; d) be two points, which have distance a2 + b2 and
c2 + d2 from the origin, respectively. The transformation T2 maps them
to two lines
T2(p) : ax + by + 1 = 0 and T2(q) : cx + dy + 1 = 0
p p
which have distance 1= a2 + b2 and 1= c2 + d2 from the origin, respectively.
Therefore,
Observation 3
If a point p is closer than a point q to the origin, then the line T2(p) is
further than the line T2 (q ) from the origin. Similarly, if a line l1 is closer
than a line l2 to the origin, then the point T2(l1) is further than the point
T2 (l2) from the origin.
Finally, it is also easy to check the following observation.
Observation 4
If two points p and q are on the same ray starting from the origin, then
the lines T2 (p) and T2 (q ) are in parallel.
We note that each improper point P is mapped to the line through
the origin having the slope and vice versa. Similarly, the origin and the
improper line are duals. Consequently, the transformation T2 should not
be applied to lines or to segments of lines which pass through the origin.
Nonetheless, the mere fact that the domain of a problem contains a line
through the origin should not make us abandon T2. By translating the axes
in one direction or another, we may be able to insure that T2 will map every
object in the domain of our problem to another proper object.
Let P = fv1 ; v2; ; vn g be a convex polygon that contains the origin O.
For a vertex vi = (ai ; bi) of P , the image of vi under T2 is the line
T2 (vi) : aix + bi y + 1 = 0
which does not pass through the origin. Call the half plane Hi with the
boundary line T2(vi ) and containing the origin the half plane dened by
T2 (vi). Let li be the line on which the boundary edge vi vi+1 of P lies.
Then the image T2(li ) of li is the intersecting point of the lines T2 (vi) and
T2 (vi+1) and the origin is contained in the intersection of the half planes Hi
and Hi+1 dened by T2(vi ) and T2(vi+1 ), respectively. Since the vertex vi
is connected to the vertex vi+1 by the boundary edge vi vi+1 of P which is
on the line li, for i = 1; ; n (here vn+1 = v1 ), the line T2 (vi) intersects
the line T2 (vi+1 ) at the point T2(li ). Thus the intersection of the half planes
Hi , dened by T2 (vi ), for i = 1; ; n is a bounded area, which is a convex
polygon containing the origin such that the sequence of boundary vertices of
the convex polygon is T2(l1), T2(l2), , T2(ln ). Therefore, we can regard the
image of the convex polygon P containing the origin under T2 to be again
a convex polygon T2 (P ) containing the origin with the boundary vertices
T2 (l1), T2(l2), , T2 (ln).
It is easy to see that given a convex polygon P that contains the origin,
the image T2 (P ) of P under T2 can be constructed in time proportional to
the number of vertices of P .
Now we apply the transformation T2 to the following problem.
CONVEX-POLYGON-INTERSECTION
Given a set of convex polygons that contain the origin, compute the
intersection of them.
Suppose that S is a set of convex polygons P1 , , Pn that contain the
origin. We rst construct the image T2(Pi ) for each convex polygon Pi in
S . Let S 0 be the set of vertices of all these convex polygons T2(P1), T2(P2 ),
, T2(Pn). We will show that the intersection of the convex polygons of S
corresponds to the convex hull of the set S 0. To prove this, we need a few
lemmas.
Let l be a line that does not pass through the origin. Draw a ray r starting
from the origin and intersecting the line l at p. Let q be an arbitrary point
Y
Y
O
r
X
p T2 ( l )
q l
T2 (q)
T2 ( p)
X
O
(a) (b)
Figure 9.3: Oq does not intersects l
on the ray r.
Lemma 9.4.1 The segment Oq intersects the line l if and only if the seg-
ment OT2(l) intersects the line T2(q ).
proof. Suppose that the segment Oq does not intersect the line l, as
shown in Figure 9.3(a). Then the point q is closer than the point p to the
origin. Thus the line T2(q ) is further than the line T2(p), by Observation 3.
Moreover, the lines T2 (q ) and T2(p) are in parallel, by Observation 4, and
the point T2(l) is on the line T2(p). Consequently, the segment OT2(l) does
not intersect the line T2(q ), see Figure 9.3(b). The inverse can be proved in
a very similar way, thus we omit it here.
Let the intersection of the convex polygons in S be I . Suppose that l is
a line on which an edge of some polygon in S lies. Then we know that T2(l)
is a point in the set S 0. We say that the line l contributes a boundary edge
to the intersection I if part of l is on the boundary of the intersection I .
Lemma 9.4.2 The line l contributes a boundary edge to the intersection I
if and only if the point T2(l) is on the convex hull of the set S 0.
proof. Suppose that the line l contributes an edge to the intersection
I but T2(l) is not a hull vertex of S 0. Let r be the ray starting from the
Y
Y
l O
l r
1 1
T2 (l1 )
T2 ( l )
p
r T2 (l2 )
l2
X r
2 T2 ( p)
O
(a) (b)
Figure 9.4: T2 (l) is not a hull vertex
origin and passing through the point T2(l). Then we must be able to nd
two points T2 (l1) and T2(l2) in the set S 0 such that if we let r1 and r2 be
the rays staring from the origin and passing through the points T2(l1) and
T2(l2), respectively, then the ray r is between the two rays r1 and r2, and
that the segment OT2(l) does not intersect the line T2(p) passing through the
points T2(l1) and T2 (l2), where p is the intersecting point of the lines l1 and
l2 , see Figure 9.4(b). By lemma 9.4.1, the segment Op does not intersect the
line l. Moreover, since the ray r is between the two rays r1 and r2, slope(l)
is between slope(l1) and slope(l2). Therefore, if we let H , H1, and H2 be
the half planes dened by the lines l, l1 , and l2 , respectively, then the area
H1 \ H2 is entirely contained in the half plane H , see Figure 9.4(a). But the
intersection I is entirely contained in H1 \ H2 thus is entirely contained in the
half plane H . But this contradicts the assumption that the line l contributes
an edge to I . This contradiction shows that the point T2(l) must be a hull
vertex of the set S 0.
The inverse that if T2(l) is a hull vertex of S 0 then the line l contributes
an edge to the intersection I can be proved similarly and is left as an exercise
to the reader.
Lemma 9.4.2 immediately suggests the following algorithm to solve the
problem CONVEX-POLYGON-INTERSECTION.
Algorithm CONVEX-POLYGON-INTERSECTION (S)
f Given a set S of convex polygons that contain the origin, compute their
intersection. g
begin
1. For each convex polygon Pi and for each edge e of the polygon Pi , if
the edge e lies on a line l, construct the point T2(l).
2. Let S 0 be the set of points produced in Step 1, construct the convex hull
CH(S 0) of S 0.
3. Let S 00 be the set of lines that are preimages of the hull vertices in
CH(S 0). Sort S 00 by slopes, let the sorted list be
l1; l2; ; lr
4. For i = 1; ; r compute the intersecting point pi of li and li+1 (here
lr+1 = l1), then sequence
p1 ; p2; ; pr
is a convex polygon that is the intersection of convex polygons in S .
end
The algorithm correctly nds the intersection of the polygons in the set
S , as we have discussed above. Moreover, if the sum of the number of edges
of the polygons in S is N , then the above algorithm trivially runs in time
O(N log N ).
Chapter 10
Geometric Problems in
Higher Dimensions
In this chapter, we introduce techniques for solving geometric problems in
more than two dimensions. Section 1 introduces the preliminaries of higher
dimensional geometry and representation of geometric objects in higher di-
mensions in a computer. Section 2 describes a divide-and-conquer algorithm
for constructing the convex hull of a set of points in 3-dimensional Euclidean
space. Section 3 gives an optimal algorithm for constructing the intersection
of a set of half-spaces in 3-dimensional Euclidean space. Section 4 demon-
strates an interesting relationship between a convex hull of a set of points
in the n-dimensional Euclidean space and the Voronoi diagram of a set of
projected points in the (n + 1)-dimensional Euclidean space. Section 3 and
Section 4 actually gives an optimal algorithm for constructing the Voronoi
diagram for a set of points in the plane using reduction techniques.
10.1 Preliminaries
10.2 Convex hulls in three dimension
From Preperata and Shamos.
10.3 Intersection of half-spaces

From Preperata and Shamos.
199
200 HIGHER DIMENSIONAL GEOMETRY
10.4 Convex hull and Voronoi diagram
From MIT Lecture Notes by Agarwal.
Chapter 11
Dynamization Techniques
The techniques are developed for problems whose database is changing over
(discrete) time. The idea is to make use of good data structures for a static
(xed) database and add to them certain dynamization mechanisms so that
insertions or deletions of elements in the database can be accommodated
eciently.
11.1 On-line construction of convex hulls

Each of the convex hull algorithms we have examined thus far requires all
of the data points to be present before any processing begins. In many geo-
metric applications, particularly those that run in real-time, this condition
cannot be met and some computation must be done as the points are being
received. In general, an algorithm that cannot look ahead at its input is
referred to as on-line, while one that operates on all the data collectively is
termed o-line. Obviously, given a problem, an on-line algorithm cannot be
more ecient than the best o-line algorithm.
Let us formally describe the problem.
ON-LINE HULL
Given a sequence of n points p1 , p2 , , pn in the plane, nd their convex
hull in such a way that after pi is processed we have the convex hull for the
set of points fp1; p2; ; pi g.
Let CH i denote the convex hull of the i points p1, p2, , pi . The
ON-LINE HULL problem is obviously reduced to the following problem: for
201
202 LOWER BOUNDS
i = 1; ; n ? 1, suppose that we have the convex hull CH i , we \insert" the
point pi+1 properly into CH i to obtain the convex hull CH i+1 . Thus, an
algorithm for ON-LINE HULL should look pretty much like the algorithm
HEAPSORT, as we studied in Algorithm Analysis, where we always keep a
sorted list for the rst i numbers, and insert the (i +1)st number to the list to
form a sorted list of the rst (i +1) numbers. In fact, we will use a technique
pretty similar to HEAPSORT to solve the ON-LINE HULL problem.
An on-line algorithm must spend at least time
(n log n), when the last
point pn has been processed, since we have shown that
(n log n) is a lower
bound for o-line algorithms of construction of convex hulls. Therefore, the
best we can expect is to insert pi+1 into the hull CH i in time O(log n). In
other words, if an algorithm inserts each point pi+1 into the convex hull CH i
in time O(log n), for i = 1; 2; ; n ? 1, then the algorithm is optimal.
Now let us see how we insert the point pi+1 into the convex hull CH i .
There are two possible cases, either the point pi+1 is internal to the convex
hull CH i , then CH i = CH i+1 and we do nothing; or the point pi+1 is
external to the convex hull CH i , then we have to construct the two bridges
from the point pi+1 to the convex hull CH i and form the convex hull CH i .
Therefore, the algorithm should look like the following:
Algorithm INSERTVERTEX
begin
1. if pi+1 is internal to CH i , then do nothing.
2. else nd the two bridges B1 and B2 from pi+1 to CH i . Let q1 and q2
be the points in CH i that are on the bridges B1 and B2 , respectively,
replace a chain on CH i that is between q1 and q2 by two line segments
q2pi+1 and pi+1 q1 .
end
Step 2 in the above algorithm involves SEARCHING the points q1 and
q2, DELETING a chain on CH i between q1 and q2 , and INSERTING the
point pi+1 . To make our algorithm optimal, all these operations should be
done in time O(log n). Thus the 2-3 trees introduced in Chapter 1 seems a
proper data structure for this purpose.
Let us store the convex hull CH i in a 2-3 tree T in the following way.
The hull vertices of CH i are stored in the leaves of T from left to right
in the counterclockwise ordering on the hull CH i . Each non-leaf vertex v
ON-LINE CONSTRUCTION 203
p' p'
p pi+1
pi+1
p pi+1 p
p' p''
p'' p''
Concave Reflex Supporting
Figure 11.1: Concave, re ex, and supporting points
of T keeps three pieces of information, L(v ), M (v ), and R(v ), where L(v )

contains the right most hull vertex vl stored in the subtree rooted at the left
son of v , together with the two neighbors of vl on the hull CH i . Similarly,
M (v) and R(v) contains the right most hull vertex vm and vr stored in the
subtrees rooted at the middle son and right son of v , respectively, together
with their two neighbors on the hull CH i .
Let p be a hull vertex of CH i and let p0 and p00 be the two neighbors of p
on CH i . Draw a line segment pi+1 p between the point p and pi+1 . Let be
the angle that is less than and formed by the line segments pp0 and pp00,
and let l be the straight line passing through the two points p and pi+1 . We
say that the vertex p is concave with respect to pi+1 if the points p0 and p00
are in two dierent sides of the line l and the point pi+1 is within the wedge
of the angle . The point p is re ex with respect to pi+1 if the points p0 and
p00 are in two dierent sides of the line l and the point pi+1 is outside the
wedge of the angle . The point pi+1 is supporting with respect to pi+1 if the
two points p0 and p00 are in the same side of the line l. Figure 11.1 depicts
these three dierent cases.
Note that given the points p, p0, p00, and pi+1 , we can decide in constant
time if the point p is concave, re ex, or supporting with respect to the point
pi+1 .
It is easy to see that if pi+1 is internal to CH i , then all hull vertices of
CH i are concave with respect to pi+1 , and if pi+1 is external to CH i , then
exactly two hull vertices of CH i are supporting with respect to pi+1 , which
are the two points q1 and q2 in Step 2 in the algorithm INSERTVERTEX.
Without loss of generality, we suppose that q1 is the \right supporting
point" with respect to pi+1 such that the whole convex hull CH i lies on
204 LOWER BOUNDS
the left side of pi+1 q1 (we say that a point q is on the left (right) side of a
directed line segment p0 p00 if q is on our left (right) side when we travel the
straight line passing through the points p0 and p00 in the direction from p0 to
p00). Similarly, we call the point q2 the \left supporting point" with respect
to pi+1 .
Suppose that the point pi+1 is external to the convex hull CH i , we discuss
how to nd the right and left supporting points q1 and q2 with respect to
pi+1 in the 2-3 tree representing the convex hull CH i . Since the algorithms
are similar for nding the right supporting point and left supporting point,
we only discuss the algorithm for nding the right supporting point q1 .
Recursively, suppose that we know that the point q1 is stored in a subtree
T (v) rooted at a non-leaf vertex v. The root v contains three pieces of
information L(v ), M (v ), and R(v ) for its left son LSON(v), middle son
MSON(v), and right son RSON(v), respectively. We rst use the information
stored in M (v ) and R(v ) to decide if q1 is stored in the right son RSON(v) of
v. If q1 is not stored in the right son RSON(v), then we use the information
stored in L(v ) and M (v ) to decide that q1 is stored in the left son LSON(v)
or in the middle son MSON(v). Since the methods for these two decisions
are similar, we only describe how we use the information L(v ) and M (v ) to
decide in which of the left and middle sons the right supporting point q1 is
stored. Since L(v ) contains the right most point vl in the subtree LSON(v)
together with its two neighbors on the convex hull CH i , we can decide in
constant time that the point vl is concave, re ex, or supporting with respect
to pi+1 . If vl is the right supporting point with respect to pi+1 , then we are
done. Therefore, we only have to consider the cases that vl is concave, re ex,
or left supporting, with respect to pi+1 . Again, the processes for these three
cases are quite similar, we only discuss the case that vl is re ex with respect
to pi+1 .
So we suppose that vl is re ex with respect to pi+1 . Let the right most
point in the subtree MSON(v) be rm (the point rm and its neighbors on
CH i are contained in the information M (v) of v. There are six dierent
positions, relative to the position of vl , for vm to locate:
1. The point vm is concave with respect to pi+1 , and vm is on the right
of pi+1 vl .
2. The point vm is concave with respect to pi+1 , and vm is on the left of
pi+1 vl.
3. The point vm is re ex with respect to pi+1 , and vm is on the right of
vm
vl pi+1
vl pi+1
vm
(1) (2)
vm
vl pi+1
vl p
i+1
vm
(3) (4)
vm
vl pi+1
vl p
i+1
vm
(5) (6)
Figure 11.2: Six positions for vm when vl is re ex
pi+1 vl.
4. The point vm is re ex with respect to pi+1 , and vm is on the left of
pi+1 vl.
5. The point vm is right supporting with respect to pi+1 .
6. The point vm is left supporting with respect to pi+1 .
Figure 11.2 illustrates all these six cases.
From Figure 11.2, it is easy to decide in which subtree the right support-
ing point q1 with respect to pi+1 is stored. We discuss this case by case.
206 LOWER BOUNDS
Remember that the hull vertices of CH i are stored in the 2-3 tree from left
to right in the counterclockwise ordering, therefore, the points stored in the
subtree MSON(v), together with the point vl , correspond to the chain on
the convex hull CH i starting from the point vl , making travel in counter-
clockwise order, and ending at the point vm . Call this chain a MSON-chain.
CASE 1 In this case, vl is re ex and vm is concave. If we travel the MSON-
chain from vl to vm , the points on the chain change from re ex to concave
with respect to pi+1 , and all points are on the right of pi+1 vl . Thus we
must pass the right supporting point q1 . Therefore, in this case, the right
supporting point q1 is stored in the middle son MSON(v).
CASE 2 The analysis is similar to Case 1, the right supporting point q1 is
stored in the middle son MSON(v).
CASE 3 In this case, both vl and vm are re ex, and vm is on the right side
of pi+1 vl . Therefore, if we travel the MSON-chain from vl to vm , the right
supporting point q1 must not be passed. Therefore, in this case the middle
son MSON(v) does not contain the right supporting point q1 . The point q1
must be stored in the left subtree LSON(v).
CASE 4 Similar to Case 2, the right supporting point q1 is stored in the
middle son MSON(v).
CASE 5 This is the most lucky case, since the right supporting point
q1 = vm.
CASE 6 Similar to Case 2, the right supporting point q1 is stored in the
middle son MSON(v).
Therefore, for each of these six cases, we can decide in constant time
which subtree we should further search. We summarize these discussions in
the following algorithm.
Algorithm RIGHTPOINT(v)
f Search the right supporting point q1 in the subtree rooted at the non-
leaf vertex v . The points vl and vm are the right most points in the subtrees
LSON(v) and MSON(v), respectively. g
begin
1. if pi+1 is external to CH i
1.1 if q1 is stored in RSON(v), call RIGHTPOINT(RSON(v));
1.2 else
1.2.1 if vl is re ex
1.2.1.1 if vm is right supporting, then done;
1.2.1.2 else if vm is re ex and on the right of pi+1vl
1.2.1.3 Call RIGHTPOINT(LSON(v));
1.2.1.4 else Call RIGHTPOINT(MSON(v));
1.2.2 else if vl is concave
1.2.3 else if vl is supporting
2. else if pi+1 is internal to CH i
2.1
end
We give a few remarks on the above algorithm.
1. To decide if the point q1 is stored in RSON(v) in Step 1.1, we use
the method similar to those in Steps 1.2.1 - 1.2.3. The only exception
is that the information used is MSON(v) and RSON(v), instead of
LSON(v) and MSON(v).
2. We actually do not need Step 2 to check if pi+1 is internal to CH i . In
fact, if pi+1 is internal to CH i , the recursive calls of Step 1 eventually
locate a single point q1 on the convex hull CH i , and this point q1 is
still concave with respect to pi+1 . Since if the point pi+1 is external to
CH i , then the nal point q1 must be the right supporting point, so if
we nd out that the nal point q1 is still concave with respect to pi+1 ,
then we conclude that the point pi+1 is internal to CH i .
3. The left supporting point q2 is found by a similar subroutind LEFT-
POINT(v).
4. With the above discussions and the similarities, the reader should have
no trouble to ll up the omitted part in the algorithm.
Therefore, to nd the right and left supporting points q1 and q2 in the
convex hull CH i , which is represented by a 2-3 tree T rooted at v , we simply
call
RIGHTPOINT(v); LEFTPOINT(v)
By the discussions above, these two supporting points can be found in
time O(log n).
Since the subroutines also tell us if pi+1 is internal to CH i , so if we are
told that pi+1 is internal to CH i , then CH i = CH i+1 and we are done.
Otherwise, the right and left supporting points q1 and q2 are returned. Let
C be the chain between q1 and q2 in the tree T . Pick any point q in the
208 LOWER BOUNDS
chain C . If the point q is re ex, then all hull vertices in the chain C should
be deleted and all other hull vertices should be kept. On the other hand, if
the point q is concave, then all hull vertices in the chain C should be kept
and all other hull vertices should be deleted. Therefore, we rst split the
the tree T into three trees T1, T2, and T3 such that the leaves of the tree
T2 are those points that are in the chain C . In the case that q is re ex, we
splice the two trees T1 and T3 into a new tree T 0, and in the case that q is
concave, we let T2 be the new tree T 0. It is clear to see that the new tree T 0
corresponds to the partial chain in CH i that should be kept in the convex
hull CH i+1 . Moreover, since the data structure we are using is a 2-3 tree,
these split and splice operations can be done in time O(log n). Finally, we
insert in time O(log n) the point pi+1 into the tree T 0 to form the 2-3 tree
representing the convex hull CH i+1 .
Summarize the above discussions, we conclude that constructing the con-
vex hull CH i+1 from the convex hull CH i can be done in time O(log n). This
consequently gives us the following theorem.
Theorem 11.1.1 The ON-LINE HULL problem can be solved by an optimal
algorithm.
Chapter 12
Randomized Methods
This chapter may contain the following materials: expected time for con-
structing convex hulls in 2-dimensional space (Preperata and Shamos, see
also Overmars Lecture Notes), expected time for constructing intersection
of half-spaces in 3-dimensional space. The papers by Clarson should be read
to nd more examples.
209
210 RANDOMIZED METHODS
Chapter 13
Parallel Constructions
Parallel random access machine (PRAM)
The computational model we are based on in this chapter is called parallel
random access machine (PRAM). This kind of machine model is also known
as the Shared-Memory Single Instruction Multiple Data computer. Here,
many processors share a common (random access) memory that they use in
the same way a group of people may use a bulletin board. Each processor
also has its own local memory in which the processor can save its own inter-
mediate computational results. When two processors wish to communicate,
they do so through the shared memory. Say processor Pi wishes to pass
a number to processor Pj . This is done in two steps. First, processor Pi
writes the number in the shared memory at a given register which is known
to processor Pj . Then, processor Pj reads the number from that register.
The number of processors of a PRAM, the size of the shared memory,
and the size of the local memory for each processor are all assumed to be
unbounded.
Depending on the way of simultaneous access of a register in the shared
memory, the class of PRAM can further be subdivided into four subclasses:
EREW PRAM, CREW PRAM, ERCW PRAM, and CRCW PRAM. We
are not going to discuss the details in this book.
13.1 Parallel construction of convex hulls

Our last discussion on the construction of convex hulls is a description of a
parallel algorithm constructing a convex hull given a set of n points in the
plane.
211
212 LOWER BOUNDS
How do we evaluate a parallel algorithm? First of all, the computation
time, here we call parallel time of a parallel algorithm is important. More-
over, a second important criterion in evaluating a parallel algorithm is the
number of processors the algorithm requires during its computation. There-
fore, a good parallel algorithm should not only run in least time, but also
use least number of processors.
To describe the parallel algorithm constructing convex hulls for planar
points, we need to be able to solve some elementary problems eciently in
parallel. We list below the parallel complexity for these problems, and ex-
plain brie y the basic idea of the parallel algorithms solving these problems.
For more detailed discussions on ecient parallel algorithms, the reader is
referred to [3].
MAXIMUM
Given n numbers, nd the maximum number.
Theorem 13.1.1 MAXIMUM can be solved in O(log n) parallel time using

O(n) processors.
proof. To nd the maximum number in a list of n numbers, we rst
use n=2 processors, each picks a pair of numbers and compares them. Then
algorithm is recursively applied on the n=2 winners.
LISTRANK
Given a linked list of n elements, compute the rank for each element.
That is, for the ith element in the list, we compute the number n ? i.
Theorem 13.1.2 LISTRANK can be solved in O(log n) parallel time using

O(n) processors.
proof. Since the idea of the algorithm PARALLELRANK is so basic and
will be used later, we describe it here in a little more detail.
We assume that the linked list is represented by a contents array c[1 : : :n]
and a successor array s[1 : : :n]. Here for all i, c[i] is initialized to 1 except
that for the last element, c[n] = 0, and s[i] is initialized to point to the next
element in the linked list except that for the last element, s[n] points to
the nth element itself. In general, c[i] is the distance between the element i
PARALLEL CONSTRUCTION 213
and the element pointed by s[i]. The following simple algorithm solves the
LISTRANK problem.
Algorithm PARALLELRANKING
begin
1. for log n iteration repeat
2. In parallel, for i = 1; ; n do
3. c[i] = c[i] + c[s[i]]; s[i] = s[s[i]].
end
The operation used in this algorithm of replacing each pointer s[i] by
the pointer's pointer s[s[i]] is called pointer jumping, and is a fundamental
technique in parallel algorithm design. The correctness and time complexity
of the algorithm can be obtained by inductively proving the following two
claims: for all i = 1; ; n, (1) at the start of each iteration, c[i] is the
distance between the element i and the element pointed by s[i]; and (2)
after log(n ? i) iterations, the point s[i] is pointing to the last element in the
linked list.
We can use one processor for each element. Then in each iteration, Step 2
and Step 3 can be executed in constant time by the processor for the element.
We conclude that in parallel time O(log n) and using O(n) processors, the
LISTRANK problem can be solved.
ARRAY-COMPRESSION
Let A be an array containing m = n + n0 elements, n of them are red and
0
n of them are blue. Delete all blue elements and compress all red elements
into an array A0 of size n.
Theorem 13.1.3 ARRAY-COMPRESSION can be solved in parallel time

O(log m) using O(m) processors.
proof. Initially, make each element of the array A a linked list of a
single element. Then for each pair of linked lists which correspond to two
consecutive elements in the array A, combine them into a single linked list.
In this process, if both linked lists are red elements, then simply connect the
tail of the rst to the head of the second and make a linked list of two red
elements; if exactly one linked list is a red element, then ignore the linked list
214 LOWER BOUNDS
of a blue element; nally, if both are linked list of blue elements, then let the
new linked list be a linked list of a single blue element. Recursively combine
these new linked lists. It is easy to see that after at most log m iterations,
all red elements are stored in a linked list, and all blue elements are thrown
away. Now use the PARALLELRANKING algorithm to compute the rank
for each red element in the nal linked list. With the rank for each red
element in the nal linked list, a processor can copy the red element directly
to the array A0 in constant time.
Theorem 13.1.4 SORTING can be solved in time O(log n) using O(n) pro-
cessors.
proof. See [9].
Now we are ready for describing the parallel algorithm for constructing
convex hulls for planar points. The algorithm looks as follows.
Algorithm PARALLELHULL
f Given a set S of n planar points stored in an array A, nd the convex
hull CH(S) of S . g
begin
1. Find the pair of points pmin and pmax with the maximum and minimum
x-coordinates;
2. Partition the set S into two sets S1 and S2 such that S1 is the set of
points in S that are above the segment pminpmax, and S2 is the set of
points in S that are below the segment pminpmax;
3. Sort S1 by x-coordinate, and sort S2 by x-coordinate;
4. construct the upper hull UH for the set S1, and construct the lower hull
LH for the set S2 ;
5. Merge UH and LH to get the convex hull CH(S).
end
Step 1 in the algorithm PARALLELHULL can be done in O(log n) par-
allel time using O(n) processors by Theorem 13.1.1. Step 2 can be done in
O(log n) parallel time using O(n) processors in the following way: we use two
new arrays A1 and A2 . A single processor is used for each i, i = 1; ; n,
to decide if the ith point pi is above or below pminpmax. If pi is above
pminpmax, put pi in the ith position in the array A1, otherwise, put pi in the
ith position in the array A2 . By Theorem 13.1.3, the arrays A1 and A2 can
be compressed in O(log n) parallel time using O(n) processors. Step 3 can
be done in O(log n) parallel time using O(n) processors by Theorem 13.1.4.
Step 5 can obviously be done in O(log n) parallel time using O(n) processors.
Therefore, if Step 4 of the algorithm can be done in O(log n) parallel time
using O(n) processors, then the algorithm PARALLELHULL takes O(log n)
parallel time and O(n) processors.
Since constructions of the upper hull UH and the lower hull LH are
similar, we only discuss the algorithm for constructing the upper hull.
Algorithm UPPER-HULL
f Given the set S1 of n planar points sorted by x-coordinates in an array
A1, construct the upper hull UH of S1 and put it in an array B1 . g
begin
p p
1. Partition the array A1 into n subarrays each containing n consec-
utive elements in A1 ;
2. Recursively construct the upper hull for the points in each subarray (in
parallel) (call them upper subhulls);
p
3. Merge these n upper subhulls into the upper hull UH of S1.
end
First let us assume that Step 3 in the algorithm UPPER-HULL can be
done in parallel time O(log n) using O(n) processors. Then since the O(n)
processors are \reusable" in Step 2, we conclude that the algorithm UPPER-
HULL uses O(n) processors. Moreover, since Step 1 can obviously be done in
O(log n) parallel time using O(n) processors, if we suppose that the parallel
running time of the algorithm is T (n), then we have the recurrence relation
p
T (n) c log n + T ( n)
It is not hard to see that T (n) = O(log n). p
Therefore, the problem is nally reduced to merging those n upper
subhulls into the upper hull of S1 in O(log n) parallel time using O(n) pro-
cessors. This is the most non-trivial part of our algorithm.
216 LOWER BOUNDS
Consider two upper subhulls H and H 0. Since we divide S1 by x-
coordinate, this ensures that the x-coordinates of any two upper subhulls
do not overlap. By recursive assumption, the upper subhulls H and H 0 are
stored in arrays in sorted order by x-coordinate. A single processor can
compute in O(log n) time the unique line which is tangent to both upper
subhulls, together with the two points of tangency. This can be done by a
binary search that is similar to the searching procedure we discussed in the
last section for on-line convex hull construction. For each pair of upper
?p sub-
hulls, construct the corresponding tangent. Since there are totally 2n < n
such pairs of upper subhulls, we can use n processors to construct all these
tangents in parallel time O(log n). p
Now we have n0 vertices, n0 n, which are the vertices on the n upper
subhulls.
pn upper Moreover, we have m edges, m 2n, which are the edges on the
subhulls and the tangents we constructed above for pairs of upper
subhulls. Note that all edges on the nal upper hull UH are within these 2m
edges. For each edge with two endpoints v1 and v2 , we make two directed
edges, one is (v1; v2) and the other is (v2 ; v1). Now for these 2m directed
edges, we sort them by the rst component. What we will obtain is an array
in which all edges incident on a vertex are consecutive. By Theorem 13.1.4,
this can be done in parallel time O(log n) using O(n) processors. Then for
each consecutive subarray corresponding to the set of edges incident on the
same vertex v , we nd the two edges lv and rv of the smallest and largest
slope with respect to the vertex v (the angle of a slope is measured from
?3=2 to =2). This can also be done in parallel time O(log n) using O(n)
processors, by Theorem 13.1.1.
The edges lv and rv form a \roof" at the vertex v . By the construction of
all these 2m edges, it is easy to see that for any vertex v that is neither pmin
nor pmax, the two edges lv and rv must exist and must be in two dierent
sides of the vertical line through v . Therefore, we will call lv and rv the left
roof and the right roof, respectively. The vertex pmin has only right roof, and
the vertex pmax has only left roof.
If the angle formed by lv and rv is greater than (measured counter-
clockwise from the left roof lv to the right roof rv ), then clearly the vertex v
cannot be on the nal upper hull UH, so we mark the vertex v by 0, meaning
\not on UH". The two corresponding roof edges lv and rv are also ignored.
Moreover, we ignore all edges that are not a roof edge for any vertex.
For each v of those vertices that have not been marked 0, we try to travel
from it \from left to right" through roof edges that have not been ignored.
Note that if a vertex v is on the upper hull UH , then the two roof edges of
v must be on the upper hull UH , and the other endpoint of the right roof
edge of v must be the next vertex on the upper hull UH , whose roof edges
are again edges on UH . Therefore, if we start with a vertex v on the upper
hull UH , the trip will be a partial chain on the upper hull UH between the
vertex v and the vertex pmax, and eventually lead us to the vertex pmax.
On the other hand, if v is not on the upper hull UH , the trip from v will
lead us either to a dead vertex (i.e., a vertex that has no right roof edge
or a vertex that has been marked 0) that is not the vertex pmax, or to a
vertex w such that the edge leading us to w is not the left roof edge of w.
Therefore, starting at a vertex v , we can decide if v is on the upper hull
UH by this kind of traveling. This kind of traveling is very similar to the
traveling we discussed for PARALLELRANKING. In fact, for each vertex
v that is not marked 0, a processor can rst check if v is a \direct dead"
vertex (i.e., a vertex w that is not pmax and either has no right roof edge,
or the right roof edge (w; u) is not the left roof edge of the other endpoint
u). If v is a direct dead vertex, make the successor s[v] of v point to v itself,
and let c[v ] = 0 (like the last element in the linked list in our algorithm
PARALLELRANKING). For all other vertex v , set c[v ] = 1 and let s[v ]
point to the other endpoint of the left roof edge of v . Now exactly like in
the algorithm PARALLELRANKING, after at most O(log n) iterations of
pointer jumping, the travels from all vertices are nished. If the successor
of a vertex v now is the vertex pmax, then the vertex v is on the upper hull
UH , otherwise, the successor of v is a direct dead vertex and the vertex v
is not on the upper hull UH . Mark all vertices on the upper hull UH by
1, and mark all vertices not on the upper hull UH by 0. Now (perhaps
after another sorting by x-coordinate) delete the vertices marked 0 using
ARRAY-COMPRESSION, and we eventually obtain the upper hull UH of
S1 , which is stored in an array. Notice the the upper hull UH now is also
ready for the further recursive calls.
Since PARALLELRANKING and ARRAY-COMPRESSION both can
be done in O(log n) parallel time using O(n) processors, we conclude that
the merge part (Step 3) in algorithm UPPER-HULL can be done in O(log n)
parallel time using O(n) processors.
This completes our description of the O(log n) parallel time, O(n) pro-
cessor parallel algorithm for constructing convex hulls for planar points.
218 LOWER BOUNDS
Bibliography
[1] A. Aggarwal and J. Wein, Computational Geometry, MIT Tech-
nical Report, MIT/LCS/RSS 3, (1988).
[2] A. V. Aho, J. E. Hopcropt, and J. D. Ullman, The Design
and Analysis of Computer Algorithms, Addison-Wesley, Reading, Mass.,
(1974).
[3] S. G. Akl, The Design and Analysis of Parallel Algorithms, Prentice
Hall, Engiewood, N.J., (1989).
[4] J. L. Bentley and M. I. Shamos, A problem in multivariate statis-
tics: Algorithms, data structure, and applications, Proc. 15th Allerton
Conf. Commun., Contr., and Comput., (1977), pp.193-201.
[5] M. Blum, W. Floyd, V. R. Pratt, R. L. Rivest, and R. E.
Tarjan, Time bounds for selection, J. Computer and System Sciences
7, (1972), pp.448-461.
[6] C. B. Boyer, A History of Mathematics, New York: Wiley, (1968).
[7] K. Q. Brown, Geometric transforms for fast geometric algorithms,
Tech. Report CMU-CS-80-101, Carnegie-Mellon, (1979).
[8] B. Chazelle, Triangulating a simple polygon in linear time, Discrete
and Computational Geometry, (1991), pp. 485-524.
[9] R. Cole, Parallel merge sort, SIAM J. Computing 17, (1988), pp.770-
785.
[10] H. Edelsbrunner, Algorithms in Combinatorial Geometry, Springer-
Verlag, Berlin, (1987).
219
220 BIBLIOGRAPHY
[11] H. Edelsbrunner, J. O'Rourke, and R. Seidel, Constructing ar-
rangements of lines and hyperplanes with applications, SIAM J. Com-
puting 15, (1986), pp.341-363.
[12] D. G. Kirkpatrick, Optimal search in planar subdivisions, SIAM
J. Computing 12, (1983), pp.28-35.
[13] D. G. Kirkpatrick and R. Seidel, The ultimate planar convex
hull algorithm? SIAM J. Computing 15, (1986), pp.287-299.
[14] D. E. Knuth, The Art of Computer Programming. Volume III: Sort-
ing and Searching, Addison-Wesley, Reading, Mass., (1973).
[15] J. B. Kruskal, On the shortest spanning subtree of a graph and the
traveling salesman problem, Proc. AMS 7, (1956), pp.48-50.
[16] D. T. Lee and F. P. Preparata, Computational Geometry - A
Survey, IEEE Transitions on Computers C-33, No. 12, (1984), pp.1072-
1101.
[17] P. McMullen and G. C. Shephard, Convex Polytopes and the Up-
per Bound Conjecture, Cambridge University Press, Cambridge, Eng-
land, (1971).
[18] K. Mehlhorn, Multidimensional Searching and Computational Ge-
ometry, Springer-Verlag, Berlin, (1984).
[19] W. M. Newman and R. F. Sproull, Principles of Interactive Com-
puter Graphics, McGraw-Hill, New York, (1979).
[20] J. O'Rourke, Art Gallery Theorems and Algorithms, Oxford, New
York, (1987).
[21] C. H. Papadimitriou and K. Steiglitz, Combinatorial Optimiza-
tion: Algorithms and Complexity, Englewood Clis, NJ: Prentice Hall,
(1982).
[22] T. Pavlidis, Algorithms for Graphics and Image Processing, Springer-
Verlag, Berlin, (1982).
[23] F. P. Preparata and M. I. Shamos, Computational Geometry: An
Introduction, Springer-Verlag, New York, (1985).
BIBLIOGRAPHY 221
[24] R. C. Prim, Shortest connection networks and some generalizations,
Bell Sys. Tech, J. 36, (1957), pp.1389-1401.
[25] J. Schwartz, M. Sharir, and J. Hopcroft, Planning, Geometry,
and Complexity of Robot Motion, Ablex Publishing Co., Norwood, New
Jersey, (1987).
[26] J. Schwartz and C. Yap, Algorithmic and Geometric Aspects of
Robotics, Vol. 1, Erlbaum, Hillsdale, New Jersey, (1987).
[27] M. I. Shamos, Geometry and statistics: Problems at the interface,
in Algorithms and Complexity, J. F. Traub, Ed., Academic, New York,
(1976), pp.251-280.
[28] G. T. Toussaint, Pattern recognition and geometrical complexity,
Proc. 5th Int. Conf. Pattern Recog., (1980), pp.1324-1347.

Chen, Computational Geometry Methods and Applications

Uploaded by

Chen, Computational Geometry Methods and Applications

Uploaded by

Computational Geometry:

Methods and Applications

2.1 A Computational model

2.2 Complexity of algorithms and problems

De nition Let A be an algorithm. The time complexity of A is O(f (n))

De nition A function u(n) is an upper bound on the time complexity of a

The proof of the following theorem is straightforward and left to the

Where the procedure ADDSON is implemented by the following recursive

Algorithm MINIMUM(T, min)

Algorithm DEL(T, x, done, 1son)

Algorithm SPLICE(T, T1, T2)

Algorithm SPLIT(T, x, T1, T2)

{Split T into T1 and T2 such that all elements in T1 are less

proof. That h(s1 )  h(T1(1)) is fairly clear since T1(1) is obtained by

Figure 2.1: The planar imbedding of K4

Doubly Connected Edge List (DCEL)

Jordan Curve Theorem Let C be a simple closed curve in the

The k-dimensional Euclidean space E k is the space of all k-tuples

3.1 Convex hulls

De nition Let L  E k . The convex hull CH(L) of L is the smallest

3.2 Proximity problems

Figure 3.1: The points that are closer to pi than to pj

3.4 Geometric searching

4.1 Intersection of line segments

Given: n segments S1, S2, ... Sn

{ Implicitly, we use a vertical line L to sweep the plane. At any

Let us analyze the algorithm. Step 1, sorting the 2n endpoints of the

O(n log n) + O(1) + n O(log n) + (n + m) O(log(n + m))

Observe that m is at most n2 , so log(n + m) = O(log n). Thus we

Algorithm JARVIS'S MARCH

Given: a set S of n points in the plane

Time complexity of Jarvis's March

4.2.2 Graham Scan

Algorithm GRAHAM SCAN

Given: a set S of n points in the plane

Algorithm MODIFIED GRAHAM SCAN

Given: a set S of n points in the plane

Figure 4.1: The convex polygon P

Given: a convex polygon P = { u(1), ...., u(m) } in

The addition i = i + 1 in the algorithm should be \(mod m)", that is,

Given: a set S of n points in the plane

4.4.1 Triangulating a monotone polygon

Given: a monotone polygon P

We rst discuss the correctness of the algorithm. Each execution of the

4.4.3 Regularization of PSLGs

Given: a PSLG G of n vertices, represented by a DCEL

Divide and Conquer

Algorithm DIVIDE AND CONQUER

Given: A problem P of size n

The \size" of the problem P is a reasonable measure of the quantity of

5.1 Convex hulls again

Given: a set S of n points in the plane

The subroutine MHULL(S) is as follows.

Given: a set S of n points in the plane, sorted by

Algorithm UpperBridge(CH(S_1), CH(S_2))

Given: two convex hulls CH(S_1) and CH(S_2) that

The lower bridge of CH (S1) and CH (S2) can be found by an algorithm

Given: a set S of n points in the plane

Where the subroutines UpperHULL and LowerHULL are similar. We

Given: a set S of points in the plane such that

Similar to QUICKSORT, it can be proved that in the worst case, the

5.2 The Voronoi diagram

Figure 5.1: A Voronoi vertex and its incident Voronoi edges

Lemma 5.2.1 Every Voronoi vertex has degree exactly three.

Figure 5.2: The nearest points de nes a Voronoi edge

the nearest point in S can be found by \locally" looking at the corresponding

5.3 Constructing the Voronoi diagram

Algorithm VORONOI DIAGRAM

Given: a set S of n points in the plane

Where the subroutine Voronoi(S) is given as follows.

Given: a set S of n points in the plane, sorted

Figure 5.3: A horizontal line separating v from v1 and v2 .

Recall that a chain C is said to be monotone if any horizontal line inter-

Figure 5.4: Two separated chains in 

So no connected component of  can be a cycle. Finally, we investigate

Algorithm MERGE(Vor(S_L), Vor(S_R))

Denition Let A be an algorithm. The time complexity of A is O(f (n))

Denition A function u(n) is an upper bound on the time complexity of a

proof. That h(s1 ) h(T1(1)) is fairly clear since T1(1) is obtained by

Denition Let L E k . The convex hull CH(L) of L is the smallest

Figure 5.2: The nearest points denes a Voronoi edge

Figure 5.4: Two separated chains in

So no connected component of can be a cycle. Finally, we investigate

Figure 5.5: makes only right turn in VL

6.2.3 Renement method I: on rectangles

Denition An n m matrix M = (ai;j ) is monotone if for any two pairs