Advanced Algorithms Computational Geometry Prof. Karen Daniels. Spring, 2010

Transcription

1 UMass Lowell Computer Science Advanced Algorithms Computational Geometry Prof. Karen Daniels Spring, 2010 Lecture 3 O Rourke Chapter 3: 2D Convex Hulls Thursday, 2/18/10

2 Chapter 3 2D Convex Hulls Definitions Gift Wrapping Graham Scan QuickHull Incremental Divide-and id and-conquer Lower Bound in Ω(nlgn)

3 Convexity & Convex Hulls source: O Rourke, Computational Geometry in C A convex combination of points x 1,..., x k is a sum of the form α 1 x α k x k where α 0 i and α1 + L+ α =1 i Convex hull of a set of points is the set of all convex combinations of points in the set. k We will construct boundary of convex hull. nonconvex polygon source: textbook Cormen et al. convex hull of a point set

4 Naive Algorithms for Extreme Points Algorithm: : INTERIOR POINTS for each i do for each j = i do for each k = j = i do for each L = k = j = i do if p L in triangle(p i, p j, p k ) then p L is nonextreme O(n 4 ) This is essentially de Berg et al. s SLOWCONVEXHULL in their Chapter 1. Algorithm: : EXTREME EDGES for each i do for each j = i do for each k = j = i do if p k is not (left or on) (p i, p j ) then (p i, p j ) is not extreme O(n 3 ) source: O Rourke, Computational Geometry in C

5 Algorithms: 2D Gift Wrapping Use one extreme edge as an anchor for finding the next Algorithm: : GIFT WRAPPING i 0 index of the lowest point i i 0 repeat for each j = i Compute counterclockwise angle θ from previous hull edge k index of point with smallest θ Output (p i, p k ) as a hull edge i k until i = i 0 source: O Rourke, Computational Geometry in C θ O(n 2 )

6 Gift Wrapping source: textbook Cormen et al Output Sensitivity: O(n 2 ) run-time is actually O(nh) where h is the number of vertices of the convex hull.

7 Algorithms: 2D QuickHull Concentrate on points close to hull boundary Named df for similarity il it to Quicksort Algorithm: : QUICK HULL function QuickHull(a,b,S) if S = 0 return() else c index of point with max distance from ab A points strictly right of (a,c) B points strictly right of (c,b) return QuickHull(a,c,A) + (c) + QuickHull(c,b,B) a A c b finds one of upper or lower hull O(n 2 ) source: O Rourke, Computational Geometry in C

8 Graham s Algorithm source: O Rourke, Computational Geometry in C Points sorted angularly provide star-shaped shaped starting point Prevent dents as you go via convexity testing θ Algorithm: : GRAHAM SCAN, Version B Find rightmost lowest point; label it p 0. Sort all other points angularly about p 0. In case of tie, delete point(s) closer to p 0. Stack S (p 1, p 0 ) = (p t, p t-1 ); t indexes top i 2 while i < n do if p i is strictly left of p t-1 p t then Push(p i, S) and set i i +1 else Pop(S) multipop O(nlgn) p 0

9 Graham Scan source: textbook Cormen et al.

10 Graham Scan 33.7 source: textbook Cormen et al.

11 Graham Scan 33.7 source: textbook Cormen et al.

12 Graham Scan source: textbook Cormen et al.

13 Graham Scan source: textbook Cormen et al.

14 Algorithms: 2D Incremental source: O Rourke, Computational Geometry in C Add points, one at a time update hull for each new point Key step becomes adding a single point to an existing hull. Find 2 tangents Results of 2 consecutive LEFT tests differ Idea can be extended to 3D. This is essentially de Berg et al. s CONVEXHULL in their Chapter 1. Algorithm: : INCREMENTAL ALGORITHM Let H 2 ConvexHull{p 0,p 1,p 2 } for k 3 to n - 1 do ConvexHull{ H k-1 U p k } H k O(n 2 ) can be improved to O(nlgn)

15 Algorithms: 2D Divide-and-Conquer source: O Rourke, Computational Geometry in C Divide-and-Conquer in a geometric setting O(n) merge step is the challenge Find upper and lower tangents t A Lower tangent: find rightmost pt of A & leftmost pt of B; then walk it downwards Idea can be extended d to 3D. B Algorithm: : DIVIDE-and-CONQUER Sort points by x coordinate Divide points into 2 sets A and B: A contains left n/2 points B contains right n/2 points Compute ConvexHull(A) and ConvexHull(B) recursively Merge ConvexHull(A) and ConvexHull(B) O(nlgn)

16 Lower Bound of Ω(nlgn) source: O Rourke, Computational Geometry in C Worst-case time to find convex hull of n points in algebraic decision tree model is in Ω(nlgn) Proof uses sorting reduction: Given unsorted list of n numbers: (x 1,x 2,, x n ) Form unsorted set of points: (x 2 i, x i2 )f for each x i Convex hull of points produces sorted list! Parabola: every yp point is on convex hull Reduction is O(n) (which is in o(nlgn)) Finding convex hull of n points is therefore at least as hard as sorting n points, so worst-case time is in Ω(nlgn) (nlgn) Parabola for sorting 2,1,3 How does this relate to output-sensitive results?