CSE 546, Fall, 2016 Homework 1

Transcription

1 CSE 546, Fall, 2016 Homework 1 Due at the beginning of class Thursday, Sept. 15 at 2:30pm. Accepted without penalty until Friday, noon, in my mailbox in the Dept. office, third floor of Jolley. Notes about homework: Whenever you are asked to present an algorithm,you should present three things: the algorithm, an informal proof of its correctness, and a derivation of its running time. Remember that your description is intended to be read by a human, not a compiler, so conciseness and clarity are preferred over technical details. Unless otherwise stated, you may use any results from class, or results from any standard algorithms text. Giving careful and rigorous proofs can be quite cumbersome in geometry, and so you are encouraged to use intuition and give illustrations whenever appropriate. Beware, however, that a poorly drawn figure can make certain erroneous hypotheses appear to be obviously correct. Throughout the semester, unless otherwise stated, you may assume that input objects are in general position. For example, you may assume that no two points have the same x-coordinate, no three points are collinear, no four points are co-circular. Also, unless otherwise stated, you may assume that any geometric primitive involving a constant number of objects each of constant complexity can be computed in O(1) time. Collaboration: and is listed here: The collaboration policy for this class is adopted from Jeremy Buhler s classes The short version of this policy is that you are allowed to discuss homework problems with other classmates, but you are not allowed to take away written notes from that discussion. All your work towards writing up homework solutions must be done on your own. Practice Problems: 1. A set Q R 2 is star-shaped if there exists a point c Q, such that for every point q Q, the line segment cq is contained in Q. Prove or disprove: (a) Every star-shaped set is convex. (b) Every convex set is star-shaped. (c) The union of two convex sets is convex. (d) The intersection of two convex sets is convex. (e) The intersection of two star-shaped sets is convex. (f) The intersection of a convex set and a star-shaped set is convex Solution: Counter examples for problems a,c,e,f are shown on the figure. Problem 1b: Every convex set is star shaped. Let S be any convex set. We need to prove that this is star shaped. The definition of convex is: x,y S the convex combination of x and y is also in S. Informally, if you pick any two points in S, all the points on the line segment between S are also in S.

2 Figure 1: Counter examples for parts of problem 1 So, pick any point of S. Any point at all. Call that point c. Because S is convex, then y S the convex combination of c and y is also in S. This is the definition of a star-shaped set with c as a center point. Since such a center point exists then S is star-shaped. In fact, any point of a convex set S can be a center point. Problem 1d: The intersection of two convex sets is convex. Let S 1 and S 2 each be a convex set. Let S be the intersection fo S 1 and S 2. Our goal is to prove that S is convex. Let x, y be any two points in S. Let z be any point on the convex combination of x, y. Then, z must be in S, because z is in S 1 (because x, y are in S 1, S 1 is convex, and z is on the convex combination of x, y, and because z is in S 2 (because x, y are in S 2, S 2 is convex, and z is on the convex combination of x, y. Since z is in both S 1 and S 2 it is in the intersection of S 1 and S 2. Therefore, S is convex, because for any points x, y in S every point z on the line from x, y is in S. 2. A polygon P is star-shaped if there exists a point q inside the polygon such that for every point p in the polygon P, the line pq is contained within P. You are given the polygon P as a counterclockwise list of vertices. Give an O(n) algorithm to compute the convex hull of P. Prove the correctness of your algorithm (at least argue that every edge of your output is actually on the convex hull). Solution: Our approach is to use Graham s Scan. Usually this is an O(n log n) algorithm because we need to sort the point (either by x-coordinate, or around some point). Since are given the order of the points around a star-shaped polygon, they are *already* sorted angularly around the center of the polygon.

3 We mimic Graham s scan: relabel points so that x 1 is the bottommost point and all the rest are still ordered counterclockwise around point q. make fake point x 0 =<, 0 >, so all points are above the line from that point to x 1 push x_0 push x_1 push x_2 for i = 3..n push x_i while size(stack)>2 and orient(stack.second, stack.first, x_i) = "right turn" pop stack end end Output the elements of the stack Correctness: Every point q is initially put on the hull. A point q is discarded from the convex hull if and only if it lies in counterclockwise order between points p i, p k and p i, q, p k is a right turn. Such a point q can never be on any convex hull. Runtime: The runtime for this is O(n) using the same argument that we used for Graham s Scan in class, except that we do not need the sorting step. In particular, everytime through the loop we perform 1 operation where we push something onto the stack, and a i operations where we pop 0 or more items off the stack. The sum: i a i cannot be more than n because we cannot ever pop more items off the stack than we ve pushed on, the total runtime is O(n). Evaluated Problems: 1. (10 points) Given n points in the plane, create an O(nlogn) algorithm that constructs a simple polygon having those points as vertices. Prove that your resulting polygon is simple (no self intersections), and uses all points. Prove the correctness and analyze the asymptotic running time of your algorithm. Solution Idea: Create a line from leftmost point to rightmost point. Connect all points above that line as the upper part of the polygon, and all points below as the lower part of the polygon. Algorithm: Sort all points by x-coordinate p 1, p n are the extreme points. Create Top List and Bottom List, and put p 1 on bottom list. for k = 2... (n 1) if orient(p 1, p n, p k ), add p k to Top List

4 else add p k to Bottom List. Return the list of all points on the bottom list, then all the points on the top list (in reverse order). This gives a list of all points around the polygon in counter-clockwise order. Run-time: Sort: O(n log n) Each time through the loop: O(n) -- constant each loop iteration. Output: O(n) to iterate through Bottom list, O(n) to reverse top list. TOTAL: O(n log n). Correctness: We need to prove that this is a simple polygon and that no segments intersect. This is based on the combination of two claims. Claim 1: No edges between points on the top list can intersect with edges between points on the bottom list. This is true because the line from p 1 to p n separates those segments, so they can t intersect. Claim 2: No edges between points on the top list can intersect. This is true because the toplist is constructed between points with consecutive x-coordinates. Therefore it is monotonic in the x-direction any vertical line passes through at most 1 edge on the list, and therefore no two edges can intersect (because at the intersection point, at least, the vertical line would intersect two segments). The same argument applies to the bottom list. Since a segment cannot intersect with either another segment on its own list or the other list, there are no intersections. 2. (10 points) The convex hull is one description of the shape of a set of points. It has the problem that if there is one crazy point added to the dataset, that may dominate the shape of the hull. Another approach calculates multiple convex hulls as follows: First compute the convex hull of all the points, remove the vertices of the hull. Then compute the convex hull of the remaining points, and again remove the vertices of the hull. Repeat this until no more points remain. The final result is a collection of nested convex polygons (where the last one may degenerate to a single line segment or single point). Figure 2: A set of points and its nested set of hulls Given a set P of n points in the plane, create an O(n 2 ) time algorithm to compute this iterated sequence of hulls. Analyze the running time and prove the correctness of your algorithm. (Fact: O(n log n) is possible, but very complicated.)

5 Solution: There are many correct answers to this problem. One is based on using Graham s scan iteratively, taking advantage of the fact that Grahams scan is O(n) once you have sorted the points. Algorithm: Sort all points by x-coordinate, put into REMAINING-POINTS-LIST While REMAINING-POINTS-LIST not empty make an extra copy of REMAINING-POINTS-LIST. Run graham s scan algorithm using sorted REMAINING-POINTS-LIST (from class or the book) to find the convex hull. Remove all points used in this convex hull from the copy of REMAINING-POINTS- LIST and make this the new REMAINING POINTS LIST which is still sorted. Proof of Correctness: Every point is output on some convex hull, because points are only taken off the remaining points list when they are output on some hull. Running time. The initial sort step takes n log n. The remaining loop can happen at most n 3 times, and each iteration takes O(n) time, so the overall time is at most O(n 2 ). 3. (10 points) Let P be the polygonal path [v 1, v 2,...v n ], which has the property that at every vertex, the path turns left (that ie, v i+1 is always left of the ray from v i 1 to v i ). Give a linear time algorithm to check this path for self intersections. Prove the correctness and analyze the running time of your algorithm. Solution: Algorithm idea: We will walk through the points one at a time, and keep track of a very small number of things that have to be checked to make sure that there is no intersection. In Phase 1, while the path has the potential to grow, we keep track of a tangent line between the current point. When the path is shrinking, we keep track of the edge we currently aim at. There is a transition where this is more complicated. Updating these pointers will take overall O(n) amortized time, although individual steps may take longer. Initialization: Initialize c = 2 Initialize t = 0 % There is no intersection until the 3rd edge, so we have sefely gotten to % if the next edge is RIGHT of V_C, V_T then it is safe. Growing Phase: while c<n+1 AND orient(c,t,c+1)<0 "While not done and new line right of tangent" while orient(c+1,t,t+1)<0 "Update the tangent line if necessary" t = t+1 c=c+1 "Set up to go to the next point" % "We re either done, or a line has turned inside the tangent" % Assume we re not done, so find the segment that we are aiming at: Transition phase: % Find the closest edge that c,c+1 might hit while c<n+1 and t>0 "Check segment back from tangent

6 Figure 3: Initial tangent lines, point at which growth phase stops, and target while orient(c,c+1,t)>0 and t>0 t=t-1 if t>0 in this case, we actually found a target line. check intersection of edge (c,c+1), (t-1,t) c=c+1 %% Transition phase done, we never found a tangent as we were going backwards, so we must be % Let s find which line it actually is. Start with t past the line and walk back until we f t = c-2. while orient(c-1,c,t)>0 t = t-1. % ok, now set up for final push. while c<n+1 c = c + 1 while orient(c-1,c,t+1)>0 %while target is left, increment it. t = t+1 check intersection (c-1,c), (t,t+1), report if it exists and stop. Run Time: there are three loops. Collectively they go through all the points. Each loop also has a sub while loop. But that inner loop increments a tangent line or a target line which can only be incremented. While sometimes this may take many steps, that target line passes every veryex once, so overall run time is O(n). Proof of Correctness: In the initial phase, we maintain a tangent line from our current point to the set of all points seen so far. While we are growing, each new segment is to the right of this tangent line, which include no current point, so no intersection is possible. When the growing phase stops, each new segment adds a possible intersection. Our algorithm maintains a pointer to the closest possible segment. In the transition phase this closest possible segment may be on the outer edge of the expanding section, and in the shrinking phase it is the

7 first edge (going backward from the current edge) whose endpoints are on either side of the current edge. These closest edges that we might intersect form a barrier; if we don t intersect these edges, we can t get past them to intersect any other edges. Therefore, the few edge intersections that we do check suffice.