Lecture 2: Fixed-Radius Near Neighbors and Geometric Basics

Transcription

1 structure arises in many alications of geometry. The dual structure, called a Delaunay triangulation also has many interesting roerties. Figure 3: Voronoi diagram and Delaunay triangulation. Search: Geometric search roblems are of the following general form. Given a data set (e.g. oints, lines, olygons) which will not change, rerocess this data set into a data structure so that some tye of query can be answered as efficiently as ossible. For examle, a nearest neighbor search query is: determine the oint of the data set that is closest to a given query oint. A range query is: determine the set of oints (or count the number of oints) from the data set that lie within a given region. The region may be a rectangle, disc, or olygonal shae, like a triangle. Lecture 2: Fixed-Radius Near Neighbors and Geometric Basics Reading: The material on the Fixed-Radius Near Neighbor roblem is taken from the aer: The comlexity of finding fixed-radius near neighbors, by J. L. Bentley, D. F. Stanat, and E. H. Williams, Information Processing Letters, 6(6), 1977, The material on affine and Euclidean geometry is covered in many textbooks on basic geometry and comuter grahics. Fixed-Radius Near Neighbor Problem: As a warm-u exercise for the course, we begin by considering one of the oldest results in comutational geometry. This roblem was considered back in the mid 70 s, and is a fundamental roblem involving a set of oints in dimension d. We will consider the roblem in the lane, but the generalization to higher dimensions will be straightforward. We assume that we are given a set P of n oints in the lane. As will be our usual ractice, we assume that each oint is reresented by its (x, y) coordinates, denoted ( x, y ). The Euclidean distance between two oints and q, denoted q is q = ( x q x ) 2 +( y q y ) 2. Given the set P and a distance r>0, our goal is to reort all airs of distinct oints, q P such that q r. This is called the fixed-radius near neighbor (reorting) roblem. Reorting versus Counting: We note that this is a reorting roblem, which means that our objective is to reort all such airs. This is in contrast to the corresonding counting roblem, in which the objective is to return a count of the number of airs satisfying the distance condition. It is usually easier to solve reorting roblems otimally than counting roblems. This may seem counterintuitive at first (after all, if you can reort, then you can certainly count). The reason is that we know that any algorithm that reorts some number k of airs must take at least Ω(k) time. Thus if k is large, a reorting algorithm has the luxury of being able to run for a longer time and still claim to be otimal. In contrast, we cannot aly such a lower bound to a counting algorithm. Lecture Notes 5 CMSC 754

2 Simle Observations: To begin, let us make a few simle observations. This roblem can easily be solved in O(n 2 ) time, by simly enumerating all airs of distinct oints and comuting the distance between each air. The number of distinct airs of n oints is ( ) n = 2 n(n 1). 2 Letting k denote the number of airs that reorted, our goal will be to find an algorithm whose running time is (nearly) linear in n and k, ideally O(n + k). This will be otimal, since any algorithm must take the time to read all the inut and rint all the results. (This assumes a naive reresentation of the outut. Perhas there are more clever ways in which to encode the outut, which would require less than O(k) sace.) To gain some insight to the roblem, let us consider how to solve the 1-dimensional version, where we are just given a set of n oints on the line, say, x 1,x 2,...,x n. In this case, one solution would be to first sort the values in increasing order. Let suose we have already done this, and so: x 1 <x 2 <...<x n. Now, for i running from 1 to n, we consider the successive oints x i+1, x i+2, x i+3, and so on, until we first find a oint whose distance exceeds r. We reort x i together with all succeeding oints that are within distance r. r x 1 x 2 x 3 x 4 x 5 x 6 Figure 4: Fixed radius nearest neighbor on the line. The running time of this algorithm involves the O(n log n) time needed to sort the oints and the time required for distance comutations. Let k i denote the number of airs generated when we visit i. Observe that the rocessing of i involves k i +1 distance comutations (one additional comutation for the oints whose distance exceeds r). Thus, u to constant factors, the total running time is: T (n, k) = n log n + n (k i +1) = n log n + n + i=1 = n log n + n + k = O(k + n log n). This is close to the O(k + n) time we were hoing for. It seems that any aroach based on sorting is doomed to take at least Ω(n log n) time. So, if we are to imrove uon this, we cannot sort. But is sorting really necessary? Let us consider an aroach based on bucketing. 1-dimensional Solution with Bucketing: Rather than sorting the oints, suose that we subdivide the line into intervals of length r. In articular, we can take the line to be comosed of an infinite collection of half-oen intervals:...,[ 3r, 2r), [ 2r, r), [ r, 0), [0,r), [r, 2r), [2r, 3r),... In general, interval b is [br, (b +1)r). A oint x lies in the interval b = x/r. Thus, in O(n) time we can associate the n oints of P with a set of n integer bucket indices b i. Although there are an infinite number of intervals, at most n will be occuied, meaning that they contain a oint of P. There are a number of ways to organize the occuied buckets. They could be sorted, but then we are back to O(n log n) time. Since bucket indices are integers, a better aroach is to store the occuied bucket indices n i=1 k i Lecture Notes 6 CMSC 754

3 in a hash table. Thus in O(1) exected time, we can determine which bucket contains a given oint and look this bucket u in the hash table. We can store all the oints lying with any given bucket in an (unsorted) list associated with its bucket, in O(n) total time. The fact that the running time is in the exected case, rather than worst case is a bit unleasant. However, it can be shown that by using a good randomized hash function, the robability that the total running time is worse than O(n) can be made arbitrarily small. If the algorithm erforms significantly more than the exected number of comutations, we can simly chose a different random hash function and try again. This will lead to a very ractical solution. How does bucketing hel? Observe that if oint x lies in bucket b, then any successors that lie within distance r must lie either in bucket b or in b +1. This suggests the straightforward solution shown below. Fixed-Radius Near Neighbor on the Line by Bucketing (1) Store the oints of P into buckets of size r, stored in a hash table. (2) For each x P do the following: (a) Let b be the bucket containing x. (b) Search all the oints of buckets b and b +1, reort x along with all those oints x that lie within distance r of x. To avoid dulicates, we need only reort airs (x, x ) where x >x. The key question is determining the time comlexity of this algorithm is how many distance comutations are erformed in ste (2b). We comare each oint in bucket b with all the oints in buckets b and b +1. However, not all of these distance comutations will result in a air of oints whose distance is within r. Might it be that we waste a great deal of time in erforming comutations for which we receive no benefit? The lemma below shows that we erform no more than a constant factor times as many distance comutations and airs that are roduced. It will simlify things considerably if, rather than counting distinct airs of oints, we simly count all (ordered) airs of oints that lie within distance r of each other. Thus each air of oints will be counted twice, (, q) and (q, ). Note that this includes reorting each oint as a air (, ) as well, since each oint is within distance r of itself. This does not affect the asymtotic bounds, since the number of distinct airs is smaller by a factor of roughly 1/2. Lemma: Let k denote the number of (not necessarily distinct) airs of oints of P that are within distance r of each other. Let D denote the total number distance comutations made in ste (2b) of the above algorithm. Then D 2k. Proof: We will make use of the following inequality in the roof: xy x2 + y 2. 2 This follows by exanding the obvious inequality (x y) 2 0. Let B denote the (infinite) set of buckets. For any bucket b B, let b +1denote its successor bucket on the line, and let n b denote the number of oints of P in b. Define S = b B n 2 b. First we bound the total number of distance comutations D as a function of S. Each oint in bucket b comutes the distance to every other oint in bucket b and every oint in bucket b +1, and hence D = n b (n b + n b+1 ) = n 2 b + n b n b+1 b B b B = b B n 2 b + b B n b n b+1 Lecture Notes 7 CMSC 754

4 b B n 2 b + b B n 2 b + n2 b+1 2 = n 2 b + b B b B n 2 b 2 + n 2 b+1 2 b B = S + S 2 + S 2 = 2S. Next we bound the number of airs reorted from below as a function of S. Since each air of oints lying in bucket b is within distance r of every other, there are n 2 b airs in bucket b alone that are within distance r of each other, and hence (considering just the airs generated within each bucket) we have k S. Therefore we have D 2S 2k, which comletes the roof. By combining this with the O(n) exected time needed to bucket the oints, it follows that the total exected running time is O(n + k). Generalization to d dimensions: This bucketing algorithm is easy to extend to multile dimensions. For examle, in dimension 2, we bucket oints into a square grid in which each grid square is of side length r. The bucket index of a oint (x, y) is a air ( x/r, y/r ). We aly a hash function that accets two arguments. To generalize the algorithm, for each oint we consider the oints in its surrounding 3 3 subgrid of buckets. By generalizing the above arguements, it can be shown that the algorithm s exected running time is O(n + k). The details are left as an exercise. r Figure 5: Fixed radius nearest neighbor on the lane. This examle roblem serves to illustrate some of the tyical elements of comutational geometry. Geometry itself did not lay a significant role in the roblem, other than the relatively easy task of comuting distances. We will see examles later this semester where geometry lays a much more imortant role. The major emhasis was on accounting for the algorithm s running time. Also note that, although we discussed the ossibility of generalizing the algorithm to higher dimensions, we did not treat the dimension as an asymtotic quantity. In fact, a more careful analysis reveals that this algorithm s running time increases exonentially with the dimension. (Can you see why?) Geometry Basics: As we go through the semester, we will introduce much of the geometric facts and comutational rimitives that we will be needing. For the most art, we will assume that any geometric rimitive involving a Lecture Notes 8 CMSC 754

5 constant number of elements of constant comlexity can be comuted in O(1) time, and we will not concern ourselves with how this comutation is done. (For examle, given three noncolinear oints in the lane, comute the unique circle assing through these oints.) Nonetheless, for a bit of comleteness, let us begin with a quick review of the basic elements of affine and Euclidean geometry. There are a number of different geometric systems that can be used to exress geometric algorithms: affine geometry, Euclidean geometry, and rojective geometry, for examle. This semester we will be working almost exclusively with affine and Euclidean geometry. Before getting to Euclidean geometry we will first define a somewhat more basic geometry called affine geometry. Later we will add one oeration, called an inner roduct, which extends affine geometry to Euclidean geometry. Affine Geometry: An affine geometry consists of a set of scalars (the real numbers), a set of oints, and a set of free vectors (or simly vectors). Points are used to secify osition. Free vectors are used to secify direction and magnitude, but have no fixed osition in sace. (This is in contrast to linear algebra where there is no real distinction between oints and vectors. However this distinction is useful, since the two are really quite different.) The following are the oerations that can be erformed on scalars, oints, and vectors. Vector oerations are just the familiar ones from linear algebra. It is ossible to subtract two oints. The difference q of two oints results in a free vector directed from q to. It is also ossible to add a oint to a vector. In oint-vector addition + v results in the oint which is translated by v from. Letting S denote an generic scalar, V a generic vector and P a generic oint, the following are the legal oerations in affine geometry: S V V scalar-vector multilication V + V V vector addition P P V oint subtraction P + V P oint-vector addition u+v u v vector addition q q oint subtraction +v v oint vector addition Figure 6: Affine oerations. A number of oerations can be derived from these. For examle, we can define the subtraction of two vectors u v as u +( 1) v or scalar-vector division v/α as (1/α) v rovided α 0. There is one secial vector, called the zero vector, 0, which has no magnitude, such that v + 0 = v. Note that it is not ossible to multily a oint times a scalar or to add two oints together. However there is a secial oeration that combines these two elements, called an affine combination. Given two oints 0 and 1 and two scalars α 0 and α 1, such that α 0 + α 1 =1, we define the affine combination aff( 0, 1 ; α 0,α 1 ) = α α 1 1 = 0 + α 1 ( 1 0 ). Note that the middle term of the above equation is not legal given our list of oerations. But this is how the affine combination is tyically exressed, namely as the weighted average of two oints. The right-hand side (which is easily seen to be algebraically equivalent) is legal. An imortant observation is that, if 0 1, then Lecture Notes 9 CMSC 754

6 aff(,q; 1/2, 3/2) aff(,q; 0,1) aff(,q; 1/2,1/2) aff(,q; 1,0) q Figure 7: Affine combination. the oint aff( 0, 1 ; α 0,α 1 ) lies on the line joining 0 and 1.Asα 1 varies from to + it traces out all the oints on this line. In the secial case where 0 α 0,α 1 1, aff( 0, 1 ; α 0,α 1 ) is a oint that subdivides the line segment 0 1 into two subsegments of relative sizes α 1 to α 0. The resulting oeration is called a convex combination, and the set of all convex combinations traces out the line segment 0 1. It is easy to extend both tyes of combinations to more than two oints, by adding the condition that the sum α 0 + α 1 + α 2 =1. aff( 0, 1, 2 ; α 0,α 1,α 2 ) = α α α 2 2 = 0 + α 1 ( 1 0 )+α 2 ( 2 0 ). The set of all affine combinations of three (noncolinear) oints generates a lane. The set of all convex combinations of three oints generates all the oints of the triangle defined by the oints. These shaes are called the affine san or affine closure, and convex closure of the oints, resectively. Euclidean Geometry: In affine geometry we have rovided no way to talk about angles or distances. Euclidean geometry is an extension of affine geometry which includes one additional oeration, called the inner roduct, which mas two real vectors (not oints) into a nonnegative real. One imortant examle of an inner roduct is the dot roduct, defined as follows. Suose that the d-dimensional vector u is reresented by the (nonhomogeneous) coordinate vector (u 1,u 2,...,u d ). Then define d 1 u v = u i v i, i=0 The dot roduct is useful in comuting the following entities. Length: of a vector v is defined to be v = v v. Normalization: Given any nonzero vector v, define the normalization to be a vector of unit length that oints in the same direction as v. We will denote this by ˆv: ˆv = v v. Distance between oints: Denoted either dist(, q) or q is the length of the vector between them, q. Angle: between two nonzero vectors u and v (ranging from 0 to π)is ( ) u v ang( u, v) =cos 1. =cos 1 (û ˆv). u v This is easy to derive from the law of cosines. Lecture Notes 10 CMSC 754

7 Lecture 3: Orientations and Convex Hulls Reading: Chater 1 in the 4M s (de Berg, van Kreveld, Overmars, Schwarzkof). The divide-and-conquer algorithm is given in Joseh O Rourke s, Comutational Geometry in C. O Rourke s book is also a good source for information about orientations and some other geometric rimitives. Orientation: In order to make discrete decisions, we would like a geometric oeration that oerates on oints in a manner that is analogous to the relational oerations (<, =,>) with numbers. There does not seem to be any natural intrinsic way to comare two oints in d-dimensional sace, but there is a natural relation between ordered (d +1)-tules of oints in d-sace, which extends the notion of binary relations in 1-sace, called orientation. Given an ordered trile of oints, q, r in the lane, we say that they have ositive orientation if they define a counterclockwise oriented triangle, negative orientation if they define a clockwise oriented triangle, and zero orientation if they are collinear (which includes as well the case where two or more of the oints are identical). Note that orientation deends on the order in which the oints are given. r ositive q negative r q r zero Figure 8: Orientations of the ordered trile (, q, r). Orientation is formally defined as the sign of the determinant of the oints given in homogeneous coordinates, that is, by reending a 1 to each coordinate. For examle, in the lane, we define 1 x y Orient(, q, r) =det 1 q x q y. 1 r x r y Observe that in the 1-dimensional case, Orient(, q) is just q. Hence it is ositive if <q, zero if = q, and negative if >q. Thus orientation generalizes <, =,>in 1-dimensional sace. Also note that the sign of the orientation of an ordered trile is unchanged if the oints are translated, rotated, or scaled (by a ositive scale factor). A reflection transformation, e.g., f(x, y) =( x, y), reverses the sign of the orientation. In general, alying any affine transformation to the oint alters the sign of the orientation according to the sign of the matrix used in the transformation. In general, given an ordered 4-tule oints in 3-sace, we can also define their orientation as being either ositive (forming a right-handed screw), negative (a left-handed screw), or zero (colanar). This can be generalized to any ordered (d +1)-tule oints in d-sace. Areas and Angles: The orientation determinant, together with the Euclidean norm can be used to comute angles in the lane. This determinant Orient(, q, r) is equal to twice the signed area of the triangle qr (ositive if CCW and negative otherwise). Thus the area of the triangle can be determined by dividing this quantity by 2. In general in dimension d the area of the simlex sanned by d +1oints can be determined by taking this determinant and dividing by (d!). Once you know the area of a triangle, you can use this to comute the area of a olygon, by exressing it as the sum of triangle areas. (Although there are other methods that may be faster or easier to imlement.) Recall that the dot roduct returns the cosine of an angle. However, this is not helful for distinguishing ositive from negative angles. The sine of the angle θ = qr (the signed angled from vector q to vector r q) can q =r zero q Lecture Notes 11 CMSC 754

8 be comuted as sin θ = q r q Orient(q,, r). (Notice the order of the arameters.) By knowing both the sine and cosine of an angle we can unambiguously determine the angle. Convexity: Now that we have discussed some of the basics, let us consider a fundamental structure in comutational geometry, called the convex hull. We will give a more formal definition later, but the convex hull can be defined intuitively by surrounding a collection of oints with a rubber band and letting the rubber band sna tightly around the oints. Figure 9: A oint set and its convex hull. There are a number of reasons that the convex hull of a oint set is an imortant geometric structure. One is that it is one of the simlest shae aroximations for a set of oints. It can also be used for aroximating more comlex shaes. For examle, the convex hull of a olygon in the lane or olyhedron in 3-sace is the convex hull of its vertices. (Perhas the most common shae aroximation used in the minimum axis-arallel bounding box, but this is trivial to comute.) Also many algorithms comute the convex hull as an initial stage in their execution or to filter out irrelevant oints. For examle, in order to find the smallest rectangle or triangle that encloses a set of oints, it suffices to first comute the convex hull of the oints, and then find the smallest rectangle or triangle enclosing the hull. Convexity: A set S is convex if given any oints, q S any convex combination of and q is in S, or equivalently, the line segment q S. Convex hull: The convex hull of any set S is the intersection of all convex sets that contains S, or more intuitively, the smallest convex set that contains S. Following our book s notation, we will denote this CH(S). An equivalent definition of convex hull is the set of oints that can be exressed as convex combinations of the oints in S. (A roof can be found in any book on convexity theory.) Recall that a convex combination of three or more oints is an affine combination of the oints in which the coefficients sum to 1 and all the coefficients are in the interval [0, 1]. Some Terminology: Although we will not discuss toology with any degree of formalism, we will need to use some terminology from toology. These terms deserve formal definitions, but we are going to cheat and rely on intuitive definitions, which will suffice for the sort simle, well behaved geometry objects that we will be dealing with. Beware that these definitions are not fully general, and you are refered to a good text on toology for formal definitions. For our uroses, define a neighborhood of a oint to be the set of oints whose distance to is strictly less than some ositive r, that is, it is the set of oints lying within an oen ball of radius r centered about. Given a set S, a oint is an interior oint of S if for some radius r the neighborhood about of radius r is contained within S. A oint is an exterior oint if it an interior oint for the comlement of S. Points that are neither interior or exterior are boundary oints. A set is oen if it contains none of its boundary oints and closed if its comlement is oen. If is in S but is not an interior oint, we will call it a boundary oint. We say that a geometric set is bounded if it can be enclosed in a ball of finite radius. A comact set is one that is both closed and bounded. Lecture Notes 12 CMSC 754

9 In general, convex sets may have either straight or curved boundaries and may be bounded or unbounded. Convex sets may be toologically oen or closed. Some examles are shown in the figure below. The convex hull of a finite set of oints in the lane is a bounded, closed, convex olygon. Neighborhood Oen Closed Unbounded Nonconvex Convex Figure 10: Terminology. Convex hull roblem: The (lanar) convex hull roblem is, given a set of n oints P in the lane, outut a reresentation of P s convex hull. The convex hull is a closed convex olygon, the simlest reresentation is a counterclockwise enumeration of the vertices of the convex hull. (A clockwise is also ossible. We usually refer counterclockwise enumerations, since they corresond to ositive orientations, but obviously one reresentation is easily converted into the other.) Ideally, the hull should consist only of extreme oints, in the sense that if three oints lie on an edge of the boundary of the convex hull, then the middle oint should not be outut as art of the hull. There is a simle O(n 3 ) convex hull algorithm, which oerates by considering each ordered air of oints (, q), and the determining whether all the remaining oints of the set lie within the half-lane lying to the right of the directed line from to q. (Observe that this can be tested using the orientation test.) The question is, can we do better? Graham s scan: We will resent an O(n log n) algorithm for convex hulls. It is a simle variation of a famous algorithm for convex hulls, called Graham s scan. This algorithm dates back to the early 70 s. The algorithm is based on an aroach called incremental construction, in which oints are added one at a time, and the hull is udated with each new insertion. If we were to add oints in some arbitrary order, we would need some method of testing whether oints are inside the existing hull or not. To avoid the need for this test, we will add oints in increasing order of x-coordinate, thus guaranteeing that each newly added oint is outside the current hull. (Note that Graham s original algorithm sorted oints in a different way. It found the lowest oint in the data set and then sorted oints cyclically around this oint.) Since we are working from left to right, it would be convenient if the convex hull vertices were also ordered from left to right. The convex hull is a cyclically ordered sets. Cyclically ordered sets are somewhat messier to work with than simle linearly ordered sets, so we will break the hull into two hulls, an uer hull and lower hull. The break oints common to both hulls will be the leftmost and rightmost vertices of the convex hull. After building both, the two hulls can be concatenated into a single cyclic counterclockwise list. Here is a brief resentation of the algorithm for comuting the uer hull. We will store the hull vertices in a stack U, where the to of the stack corresonds to the most recently added oint. Let first(u) and second(u) denote the to and second element from the to of U, resectively. Observe that as we read the stack from to to bottom, the oints should make a (strict) left-hand turn, that is, they should have a ositive orientation. Thus, after adding the last oint, if the revious two oints fail to have a ositive orientation, we o them off the stack. Since the orientations of remaining oints on the stack are unaffected, there is no need to check any oints other than the most recent oint and its to two neighbors on the stack. Let us consider the uer hull, since the lower hull is symmetric. Let 1, 2,..., n denote the set of oints, sorted by increase x-coordinates. As we walk around the uer hull from left to right, observe that each consecutive trile along the hull makes a right-hand turn. That is, if, q, r are consecutive oints along the uer hull, then Orient(, q, r) < 0. When a new oint i is added to the current hull, this may violate the right-hand turn Lecture Notes 13 CMSC 754

10 (1) Sort the oints according to increasing order of their x-coordinates, denoted 1, 2,..., n. (2) Push 1 and then 2 onto U. (3) for i =3to n do: (a) while size(u) 2 and Orient( i, first(u), second(u)) 0, o U. (b) Push i onto U. Graham s Scan uer hull i i 1 n o lower hull rocessing [i] after adding [i] Figure 11: Convex hulls and Graham s scan. invariant. So we check the last three oints on the uer hull, including i. They fail to form a right-hand turn, then we delete the oint rior to i. This is reeated until the number of oints on the uer hull (including i ) is less than three, or the right-hand turn condition is reestablished. See the text for a comlete descrition of the code. We have ignored a number of secial cases. We will consider these next time. Analysis: Let us rove the main result about the running time of Graham s scan. Theorem: Graham s scan runs in O(n log n) time. Proof: Sorting the oints according to x-coordinates can be done by any efficient sorting algorithm in O(n log n) time. Let D i denote the number of oints that are oed (deleted) on rocessing i. Because each orientation test takes O(1) time, the amount of time sent rocessing i is O(D i +1). (The extra +1 is for the last oint tested, which is not deleted.) Thus, the total running time is roortional to n n (D i +1) = n + D i. i=1 To bound i D i, observe that each of the n oints is ushed onto the stack once. Once a oint is deleted it can never be deleted again. Since each of n oints can be deleted at most once, i D i n. Thus after sorting, the total running time is O(n). Since this is true for the lower hull as well, the total time is O(2n) =O(n). Convex Hull by Divide-and-Conquer: As with sorting, there are many different aroaches to solving the convex hull roblem for a lanar oint set P. Next we will consider another O(n log n) algorithm, which is based on the divide-and-conquer design technique. It can be viewed as a generalization of the famous MergeSort sorting algorithm (see Cormen, Leiserson, and Rivest). Here is an outline of the algorithm. It begins by sorting the oints by their x-coordinate, in O(n log n) time. The asymtotic running time of the algorithm can be exressed by a recurrence. Given an inut of size n, consider the time needed to erform all the arts of the rocedure, ignoring the recursive calls. This includes the time to artition the oint set, comute the two tangents, and return the final result. Clearly the first and third of these stes can be erformed in O(n) time, assuming a linked list reresentation of the hull vertices. Below we i=1 Lecture Notes 14 CMSC 754

11 Divide-and-Conquer Convex Hull (1) If P 3, then comute the convex hull by brute force in O(1) time and return. (2) Otherwise, artition the oint set P into two sets A and B, where A consists of half the oints with the lowest x-coordinates and B consists of half of the oints with the highest x-coordinates. (3) Recursively comute H A = CH(A) and H B = CH(B). (4) Merge the two hulls into a common convex hull, H, by comuting the uer and lower tangents for H A and H B and discarding all the oints lying between these two tangents. uer tangent b A B A a B lower tangent (a) (b) Figure 12: Comuting the lower tangent. will show that the tangents can be comuted in O(n) time. Thus, ignoring constant factors, we can describe the running time by the following recurrence. { 1 if n 3 T (n) = n +2T (n/2) otherwise. This is the same recurrence that arises in Mergesort. It is easy to show that it solves to T (n) O(n log n) (see CLR). All that remains is showing how to comute the two tangents. One thing that simlifies the rocess of comuting the tangents is that the two oint sets A and B are searated from each other by a vertical line (assuming no dulicate x-coordinates). Let s concentrate on the lower tangent, since the uer tangent is symmetric. The algorithm oerates by a simle walking rocedure. We initialize a to be the rightmost oint of H A and b is the leftmost oint of H B. (These can be found in linear time.) Lower tangency is a condition that can be tested locally by an orientation test of the two vertices and neighboring vertices on the hull. (This is a simle exercise.) We iterate the following two loos, which march a and b down, until they reach the oints lower tangency. Finding the Lower Tangent LowerTangent(H A,H B ): (1) Let a be the rightmost oint of H A. (2) Let b be the leftmost oint of H B. (3) While ab is not a lower tangent for H A and H B do (a) While ab is not a lower tangent to H A do a = a 1 (move a clockwise). (b) While ab is not a lower tangent to H B do b = b +1(move b counterclockwise). (4) Return ab. Proving the correctness of this rocedure is a little tricky, but not too bad. Check O Rourke s book out for a careful roof. The imortant thing is that each vertex on each hull can be visited at most once by the search, and Lecture Notes 15 CMSC 754

12 hence its running time is O(m), where m = H A + H B A + B. This is exactly what we needed to get the overall O(n log n) running time. Lecture 4: More Convex Hull Algorithms Reading: Today s material is not covered in the 4M s book. It is covered in O Rourke s book on Comutational Geometry. Chan s algorithm can be found in T. Chan, Otimal outut-sensitive convex hull algorithms in two and three dimensions, Discrete and Comutational Geometry, 16, 1996, QuickHull: If the divide-and-conquer algorithm can be viewed as a sort of generalization of MergeSort, one might ask whether there is corresonding generalization of other sorting algorithm for comuting convex hulls. In articular, the next algorithm that we will consider can be thought of as a generalization of the QuickSort sorting rocedure. The resulting algorithm is called QuickHull. Like QuickSort, this algorithm runs in O(n log n) time for favorable inuts but can take as long as O(n 2 ) time for unfavorable inuts. However, unlike QuickSort, there is no obvious way to convert it into a randomized algorithm with O(n log n) exected running time. Nonetheless, QuickHull tends to erform very well in ractice. The intuition is that in many alications most of the oints lie in the interior of the hull. For examle, if the oints are uniformly distributed in a unit square, then it can be shown that the exected number of oints on the convex hull is O(log n). The idea behind QuickHull is to discard oints that are not on the hull as quickly as ossible. QuickHull begins by comuting the oints with the maximum and minimum, x- and y-coordinates. Clearly these oints must be on the hull. Horizontal and vertical lines assing through these oints are suort lines for the hull, and so define a bounding rectangle, within which the hull is contained. Furthermore, the convex quadrilateral defined by these four oints lies within the convex hull, so the oints lying within this quadrilateral can be eliminated from further consideration. All of this can be done in O(n) time. discard these Figure 13: QuickHull s initial quadrilateral. To continue the algorithm, we classify the remaining oints into the four corner triangles that remain. In general, as this algorithm executes, we will have an inner convex olygon, and associated with each edge we have a set of oints that lie outside of that edge. (More formally, these oints are witnesses to the fact that this edge is not on the convex hull, because they lie outside the half-lane defined by this edge.) When this set of oints is emty, the edge is a final edge of the hull. Consider some edge ab. Assume that the oints that lie outside of this hull edge have been laced in a bucket that is associated with ab. Our job is to find a oint c among these oints that lies on the hull, discard the oints in the triangle abc, and slit the remaining oints into two subsets, those that lie outside ac and those than lie outside of cb. We can classify each oint by making two orientation tests. How should c be selected? There are a number of ossible selection criteria that one might think of. The method that is most often roosed is to let c be the oint that maximizes the erendicular distance from the line ab. (For examle, another ossible choice might be the oint that maximizes the angle cba or cab. It turns out that Lecture Notes 16 CMSC 754