Convex Hulls (2D)

1. Convex Hulls (2D) Jarvis March Graham Scan Chan’s Algorithm

2. What is a convex hull? • Wikipedia: “the minimal convex set containing X, where X is a set of points in a real vector space V” • In 2D: Convex polygon of smallest area containing all given points • In 3D: Convex polyhedron of smallest volume containing all given points

3. Output-sensitive algorithms • Any algorithm with a runtime dependent not only on the input size, but on the output size as well • Occasionally pop up in problems where you can compute parts of the output one by one

4. Jarvis march • Start at the leftmost point in the set (if there are multiple, take the closest to the bottom) • For all other points, compute the angle measured ccw with down being 0o • Take point with smallest angle • Repeat, except for further steps, measure angles ccw with the line segment from current to previously selected point being 0o

5. Jarvis march

6. Can we do better? • Jarvis performs reasonably well if output size is small • Calculate angles for every point each time it progresses to a new point, and it progressed to a new point once for every point in the output • Runtime O(nh), where n = # of points, h = # of output points. • If k is large (read: O(lg n)), Jarvis is slow, can be as bad as O(n2)

7. Graham scan • Take starting point to be bottom-most point (if tied, take left-most) • Sort all points by angle with right (+x) being 0o • Iterate over points in order • If the next point forms a “left turn” with the previous two, add it to the list and continue • If “right turn”, remove the previous point until the angle becomes a left turn

8. Graham scan

9. Can we do even better? Graham scan O(n lg n) Jarvis march O(nh) O(n lg h) ?

10. Yup. • The “ultimate convex hull algorithm” published by Kirkpatrick and Seidel in 1986 achieves O(n lg h) • Uses reversal of divide-and-conquer, referred to as “marriage-before-conquest” by authors • Requires median-finding in O(n) • Chan’s algorithm, published in 1996, also achieves O(n lg h), but more simple • As a lazy CS major, I’ll use this

11. Chan’s Algorithm • Uses both Graham scan and Jarvis march as subroutines • Partitions points into smaller chunks, then derives an overall convex hull by exploiting the smaller precomputed hulls

12. Chan’s Algorithm • Suppose we know h, the size of the output • We can partition (arbitrarily) n points into 1+n/h subsets, each with h or h-1 points • Use Graham scan on each of subsets; must be done 1 + n/h times, and each takes O(h lg h), so overall runtime=(1+n/h)O(h lg h)=O(n lg h) • Finish computing convex hull from parts…

13. Chan’s Algorithm

14. Chan’s Algorithm • Problem: In general, we don’t know the size of the convex hull before we compute, so h is unknown; thus, this algorithm will not work • Instead, iterate over the algorithm with different guesses for h to converge to the answer

15. Chan’s Algorithm • For step t, let the guess for h be m = min(22t, n) • If hull is not completed in m steps, abort • Thus, each step takes O(n lg m) = O(n∙2t) • Starting t at 0, we are guaranteed to find the solution by t = • Thus, total runtime is

16. Chan’s Algorithm • Looks complicated • But, we know • Thus, • So we have a working O(n lg h) algorithm, yay

17. Other optimizations • Discard points found to be inside smaller convex hulls prior to merge step on each iteration of algorithm (if a point lies in any convex polygon, it cannot be in convex hull) • Alternatives to 22t