Advanced Algorithm Homework 4 Results and Solutions

Transcription

1 Advanced Algorithm Homework 4 Results and Solutions ID Av Ex YC

2 Problem 1 (30.5-2) Given a 6-coloring of an n-object list, show how to 3-color the list in O(1) time using n processors in an EREW PRAM. Note: There are several solutions for this problem. The following is one of them. You could also make use of MIS to compute this, as some students did. Solution In a 6-coloring list, 6 colors are used to color every node in the list such that no two adjacent nodes have the same color. The 6 colors are given the following binary codes: <000,010,100, 001,011,101>. In these six (3-bit) combinations, we used three (2-bit) combinations, namely <00,01,10> and appended either 0 or 1 to the right to make the six combinations. To make a 3-color list from a 6-color list, I will remove the rightmost bit from every color and thus return it to the original combination <00,01,10>. Notice the following: Consider two adjacent nodes n i and n i+1 in the list. Assume n i s color = <x 1 x 2 x 3 > and n i+1 s color = <y 1 y 2 y 3 >. We know that these two colors are different (the list is colored). If the rightmost bits in the two colors were equal (i.e. x 3 = y 3 ), then the rest of the two colors must be different (i.e. <x 1 x 2 > <y 1 y 2 >) The algorithm proceeds as follows: Assign processor P i (i=1, 2,,n) to every node i in the list For each processor P i, in Parallel Do if i is even (i.e. i mod 2 == 0) then Do // Assume P i s color = <x 1 x 2 x 3 > and P i+1 s color = <y 1 y 2 y 3 > if (x 3 == y 3 ) then P i s new_color = <x 1 x 2 > P i+1 s new_color = <y 1 y 2 > Else //pick either x 1 or x 2 (the one opposite to x 3 ) and swap it with x 3 If (x 1!= x 3 ) then swap(x 1,x 3 ) else swap(x 2,x 3 ) //after the swap operation we guarantee that x 3 == y 3 P i s new_color = <x 1 x 2 > P i+1 s new_color = <y 1 y 2 > After this part of the algorithm finishes, the list is half compatible, which means that every even node i is compatible with the odd node that follows it as shown in the following figure. 2

3 Resolve compatibility from for even to odd pairs of nodes. The next part of the algorithm resolves the compatibility with the rest of the nodes: For each processor P i, in Parallel Do if i is odd (i.e. i mod 2 == 1) then Do // Assume P i s new_color = <x 1 x 2 > and P i+1 s new_color = <y 1 y 2 > if (<x 1 x 2 >!= <y 1 y 2 >) then The two colors are compatible (don t do anything) Else Pick two new combinations for P i and P i+1 nodes such that <x 1 x 2 > is compatible with <y 1 y 2 > and <x 1 x 2 > is compatible with P i-1 color and <y 1 y 2 > is compatible with P i+2 color Resolve compatibility for odd to even pairs. Time analysis: The first part is performed in parallel and has a constant number of operations; O(1). The second part is performed in parallel and has a constant number of operations; O(1). Therefore, this algorithm takes O(1) total. 3

4 Problem 2 (35.1-2) Write psuedocode to sort a sequence <p 1, p 2,,p n > of n points according to their polar angles with respect to a given origin point p 0. Your procedure should take O(n lg n) time and use cross product to compare angles. Note: You have to use cross product to compare angles as specified by the problem, although there are several variants for this solution. Solution If the origin point p 0 is not the point (0,0), we need to translate all the points on the plane where p 0 becomes on the origin (0,0) We know that for any two vectors p 1 and p 2 with respect to the origin point; p 1 p 2 is the signed area of the parallelogram formed by the points (0,0), p 1, p 2, and p 1 + p 2. This area is determined by the polar angle between p 1 and p 2 and the length of p 1 and p 2. To sort the sequence of points (vectors), I will compare every vector p i to some vector p x on the x-axis, and to make this comparison fair, I will pick the point p x such that its x-value equals the x-value of the point p i (for all i). See the figure below. This way when we compute the cross product p 1 p 2 at every iteration, the resulting area can be used to compare angels between vectors. p i p x The psuedocode // I will use array A to store resulting cross product computations // assume the origin point P 0 =(x 0, y 0 ) If P 0!= (0,0) then For every point P i =(x i,y i ) where i=1 to n do P i =(x i -x 0, y i -y 0 ) //translate point p i with respect to p 0 For every point P i =(x i,y i ) where i=1 to n do P x = (x i,0) 4

5 Compute CP = p x p i A[i]= CP Call Merge_Sort(A); Return A; Correctness Notice that this psuedocode will work for the point p i above the x-axis and those points p i below the x-axis. Because, in the first case the cross product (CP) will be positive, and when CP is larger the angle is larger. In the second case, CP will be negative, and when CP is larger in the negative direction, the angle will be larger as well. p i p x is clockwise from p i, area is positive. p x p x p x is counterclockwise from p i, area is negative. p i Time analysis The first for loop takes O(n) time. The sorting takes O(n lg n) time. Total time = O(n)+O(n lg n) = O(n lg n). 5

6 Problem 3 (35.2-4) Give an O(n lg n)-time algorithm to determine whether an n-vertex polygon is simple. Solution A polygon is simple if it has no two intersecting edges. Simple polygon I will use a modified version of the Segment-Intersection algorithm as follows: Modified-Segment-Intersection(Polygon P) //input: polygon P given as a set of nodes = nodes(p) and a set of edges = edges(p). //Store the edges of P into a set of line segments S. S = edges(p); T = φ Sort the endpoints of the edges in S from left to right, breaking ties by putting points with lower y-coordinates first For each point p in the sorted list of endpoints Do If p is the left endpoint of a segment s Then INSERT(T,s) If (ABOVE(T,s) exists and intersects s) Or (BELOW(T,s) exists and intersects s) Then If intersection point p nodes(p) Then return (Non-simple) If p is the right endpoint of a segment s Then If both ABOVE(T,s) and BELOW(T,s) exist and ABOVE(T,s) intersects BELOW(T,s) Then If intersection point p nodes(p) Then return (Non-simple) DELETE(T,s) 6

7 Return (Simple) Where: INSERT(T,s): insert segment s into T. DELETE(T,s): delete segment s from T. ABOVE(T,s): return the segment immediately above segment s in T. BELOW(T,s): return the segment immediately below segment s in T. The algorithm is the same as the Segment-Intersection algorithm with the following modifications: 1- We inserted the edges of P into the set of segments S. This way we treat them as if they where independent segments. 2- When any intersection is found between any two segments, we check to see if this intersection point is a vertex on the polygon. If it is a vertex, then this intersection is ignored otherwise it is reported that P is a non-simple polygon. 3- If the for loop ends without finding any intersections (other than vertices), we report P as a simple polygon. Time analysis The algorithm has the same running time as the Segment-Intersection algorithm; The pre-sorting step takes O(n lg n) and the for loop tales O(n lg n) because we have 2n endpoints and each endpoints might take O(lg n) processing due to tree operations. Therefore, total time = 2 O(n lg n) = O(n lg n). 7

8 Problem 4 (35.3-4) Given an n-vertex, star-shaped polygon P specified by its vertices in counterclockwise order, show how to compute CH(P) in O(n) time. P The Algorithm Find the lowest node on the polygon (the one that has the smallest y- coordinate) call v 1 ; Starting from v 1 and moving counterclockwise label the n vertices of the polygon as <v 1, v 2,,v n > Stack S = φ; //start with empty stack Push (S,v 1 ); //push node v 1 onto the stack S. i = 2; While i n do v s = Top(S) //read the node on top of S into v s (don t pop) Check where the extensions of the two line segments (v s-1 v s )and (P v i )intersects, assume they intersect at point W. If W is inside the polygon then pop(s); Else Push(v i ); i = i + 1; //end if //end while Return S; //The nodes of CH(P) are all in S 8

9 Tracing the algorithm Here we will trace the first few steps of the algorithm on the example below: We pick v 1 as the lowest node and we label the rest of the nodes as follows: v 9 v 7 v 8 v 10 P v 6 v 5 v 11 v 12 v 2 v 4 v 1 v 3 Push v 1 on the stack; S = v 1 Initialize i = 2, and start the while loop: v s = Top(S) = v 1 ; The extended two line segments (v 12 v 1 ) and (P v 2 ) intersect at the point W as shown in the following figure: v 9 v 7 v 8 v 10 P v 6 v 5 v 11 v 12 v 1 v 2 W v 3 v 4 W is outside of the polygon P, so we push (v 2 ) onto the stack, S becomes = v 1, v 2. And i is incremented, i=3; Next iteration: 9

10 v s = Top(S) = v 2 ; The extended two line segments (v 1 v 2 ) and (P v 3 ) intersect at the point W as shown in the following figure: v 7 v 9 v 8 v 10 P v 6 v 5 v 11 W v 2 v 4 v 12 v 1 v 3 W is inside the polygon P, so we Pop (v 2 ) off the stack, S becomes = v 1. (i is not incremented!) Next iteration: v s = Top(S) = v 1 ; The extended two line segments (v 12 v 1 ) and (P v 3 ) intersect at the point W as shown in the following figure: v 9 v 8 v 7 v 10 P v 6 v 5 v 11 v 2 v 4 v 12 v 1 v 3 W W is outside of the polygon P, so we push (v 3 ) onto the stack, S becomes = v 1, v 3. And i is incremented, i=4. So far we know that v1 and v3 are in CH(P), we continue in the same fashion until we finish all nodes and the while terminates. When we finish, S will contain the nodes S= v 1, v 3, v 4, v 5, v 7, v 9, v 11, v 12. Time analysis Finding the lowest node will take O(n) time. The while loop will make n iterations, in each iteration we check the intersection of two segments, we perform push or pop stack operations or we check if the intersection point is inside 10

11 or outside of the polygon. All these operation takes O(1) time. Therefore, the while loop takes O(n) time. Thus, Total time = O(n)+O(n) = O(n). Problem 5 (35.4-3) The distance between two points can be defined in ways other than Euclidean. In the plane, the L m -distance between points p 1 and p 2 is given by ( x 1 x 2 m + y 1 y 2 m ) 1/m. Euclidean distance, therefore, is L 2 -distance. Modify the closest-pair algorithm to use L 1 -distance, which is also known as Manhattan distances. Note: To get full credit, you have to give your modified algorithm. It is not enough to only describe how you modified the algorithm. Solution Let Q be a set of n planner points. Pre-closet-pair(points Q){ points X = Sort_by_x_coordinates(Q); points Y = Sort_by_y_coordinates(Q); call Closest-Pair(Q, X, Y); }//end Closest-Pair(points Q, points X, points Y){ If Q 3, then { //Compute the distances between all pairs of points and report the //closest pair. Assume Q={p0, p1, p2}, where, p 0 =(x 0, y 0 ), //p 1 =(x 1, y 1 ), p 2 =(x 2, y 2 ). Compute d 0 = x 0 x 1 + y 0 y 1 Compute d 1 = x 0 x 2 + y 0 y 2 Compute d 2 = x 1 x 2 + y 1 y 2 d min = MIN (d 0, d 1, d 2 ); Return d min ; } Else{ // If Q > 3, then a Divide, Conquer & Combine approach is followed. //The divide step: Find a vertical line L, that bisects the points in P into P and P with almost equal sizes. All points in P are left of L (or on L), all points in P are right of L (or on L). Divide the array X into two arrays X and X as follows: X = contains the points of P sorted by x-coordinates. X = contains the points of P sorted by x-coordinates. Divide the array Y into two arrays Y and Y as follows: Y = contains the points of P sorted by y-coordinates. Y = contains the points of P sorted by y-coordinates. //This step is the opposite of the Merge procedure in Merge-Sort). 11

12 //The Conquer step Make first recursive call, d = Closest-Pair(P, X, Y ); Make second recursive call, d = Closest-Pair(P, X, Y ); d = MIN (d, d ); //Combine step Create a d 2d box about L. Find the array = the points of Y within distance d of L, sorted by their y-coordinates. can have at most 8 points. min = d; For each pair of points p and q in { //assume p=(x p, y p ) and q=(x q, y q ). d pq = x p x q + y p y q if (d pq < min) then min = d pq ; //end For Return min; } }//end Closest-pair. Time analysis This modified version of the closest-pair algorithm has the same running time as the original one, O(n lg n). But here we saved some time while computing the distance between points in two places: 1- When Q has three or less points, we used the L 1 -distance instead of using the Euclidean distance to get the minimum distance between theses three points. 2- During the combine step, we used the L 1 -distance instead of Euclidean distance, which will find the minimum distance among 8 points or less. In these two cases, every time we performed a distance computation, we saved two square operations and one square root operation. 12

13 Extra Credit Problem (35.1-7) Show how to compute the area of an n-vertex simple, but not necessarily convex, polygon in Θ(n) time. Note: You can solve this problem in easy way, or hard way. The basic steps in solving this problem is: 1). Partition the polygon into triangles. 2). Compute the area for each individual triangle. The easiest solution is to use cross product to compute the area for each individual triangle. For convex, all the cross products will be positive so it is clear we can simply add them together and get the area for the polygon. Surprisingly enough, the same cross product method also works for non-convex simple polygon. The signed cross product will take care everything. For example, suppose we have the following polygon. P3 P2 D P0 P4 P1 We now use P0 as starting point to divide it into triangles. The dash lines show we have triangles P 0 P 1 P 2, P 0 P 2 P 3 and P 0 P 3 P 4. Among those triangles, P 0 P 1 P 2 has a subarea P 0 DP 4 that is out of out of our non-convex polygon; P 0 P 2 P 3 has a subarea P 0 DP 3 that is out of out of our non-convex polygon. Also, we know that: area(p 0 DP 4 ) + area(p 0 DP 3 ) = area(p 0 P 3 P 4 ) 13

14 If we use cross product to compute the area, the triangle P 0 P 3 P 4 will yield a negative area. So this negative area will cancel out the two subareas that are out of our polygon when we compute the area of another two triangles. 14