2 Computing all Intersections of a Set of Segments Line Segment Intersection

Transcription

1 15-451/651: Design & Anlysis of Algorithms Novemer 14, 2016 Lecture #21 Sweep-Line nd Segment Intersection lst chnged: Novemer 8, Preliminries The sweep-line prdigm is very powerful lgorithmic design technique. It s prticulrly useful for solving geometric prolems, ut it hs other pplictions s well. We ll illustrte this y presenting lgorithms for two prolems involving intersecting collections of line segments in 2-D. Generlly speking sweepline mens tht you re processing the dt in some order (e.g. left to right order). A dt structure is mintined tht keeps the informtion gleened from the prt of the dt currently to the left of the sweepline. The sweepline moves cross soring new pieces of the input nd incorporting them into its dt structure. Oviously this is very vgue. So let s get concrete nd solve some prolems. 2 Computing ll Intersections of Set of Segments Line Segment Intersection The input is set S of line segments in the plne (ech defined y pir of points). The output is list of ll the plces where these line segments intersect. As usul, we re going to mke our lives esier y mking some geometric ssumptions. We re going to ssume tht none of the segments is verticl. We ll lso ssume tht no three segments intersect t the sme point. We ll lso ssume tht no segment hs n endpoint tht is prt of nother segment. (These ssumptions cn e voided y dding some extr cses to the lgorithm tht do not chnge the running time ounds.) There s trivil O(n 2 ) lgorithm: Just pply segment intersection to ll pirs of segments. The solution we give here will e O((n + k) log n), where k is the numer of segment intersections found y the lgorithm. To get some intuition for wht s going to hppen, consider the following figure. 1

2 Events Here we hve six segments, clled,, c, d, e, f. There re lso two segment intersections. The interesting x-coordintes re the ones where something hppens: either segment egins, or segment ends, or two segments cross. The following figure shows verticl dshed line efore ech interesting x-coordinte. Aove the dshed line is list of the segments in the sme order they pper in the digrm, long tht dshed line. Sweep Line Intersections Between ny two neighoring events, the segments (in tht rnge of x) re in some order y y from ottom to top. This order (nd which segments re there) does not chnge etween pir of neighoring interesting x coordintes. We re going to mintin dt structure tht represents the list shown t the top of the digrm. Let s cll this segment list. Look t how this list chnges s we move cross the interesting x vlues. Only one of three things cn hppen. (1) A new segment is inserted into the list. (2) A segment is removed from the list. (3) Two neighoring segments in the list cross. 2

3 Our gol is to compute the intersections mong these segments. The key oservtion tht leds to good lgorithm is tht right efore two segments cross, they must e neighors in the segment list. So the key ide of the lgorithm is tht s our segment list evolves (s we process the interesting x coordintes from left to right), we only need to consider the possile intersections etween segments tht re neighors, t some point in time, in the segment list. So our lgorithm is going to mintin two dt structures. A segment list (SL) nd n event queue (EQ). Ech event in the EQ will e leled with its type ( segment strt, segment end, segments cross ), s well s the x vlue where this hppens. The EQ is initilized with ll the segment strts nd segment ends. The EQ dt structure must support insert, findmin, nd deletemin. It s just stndrd priority queue. Although segment is defined y its two endpoints, it s going to e useful to lso use slopeintercept representtion for the line contining the segment. So segment i will hve left nd right endpoint s well s pir (m i, i ) where m i is the slope of the line nd i is the y-intercept. Consider wht we need for the SL dt structure. The items eing stored re set of segments. The ordering used is the vlue of m i x+ i, where x is the current x vlue in the ongoing sweep-line lgorithm. Requirements for the SL dt structure: Insert new segment into the dt structure. Delete segment from the dt structure. Find the successor of segment in the dt structure. Find the predecessor of segment in the dt structure. All of these opertions cn e done in O(log n) time using ny stndrd serch tree dt structure (e.g. sply trees, or AVL trees). Note in SL, the keys of the nodes store (m i, i ) not the y vlue t the time of insertion. This is so tht when we insert new segment, we insert it in the right order. An exmple where this is importnt is inserting d in the following sitution: c d c d c In the ove exmple, we wnt to insert d ove even though it is elow the y coordinte of when ws inserted. Since we store (m i, i ), we cn compute the y-coordinte of ll the segments t the current point (here, the strt of d). Since the ordering only chnges t the interesting points, SL mintins the correct tree ordering. Now we cn write the complete lgorithm. Whenever the lgorithm sys CheckForIntersection (EQ,, ), this mens tht the pir of segments nd re tested for intersection. This function will lwys 3

4 e clled when nd re neighors in the SL. If they do intersect, CheckForIntersection dds the intersection event to the EQ. def FindSegmentIntersections(S): crete n empty priority queue EQ for ech segment S, insert its strt nd end events into EQ crete n empty lnced tree SL while (EQ is not empty) E := deletemin(eq) if E is strt of segment s then insert s into SL CheckForIntersect(EQ, s, successor of s) CheckForIntersect(EQ, s, predecessor of s) else if E is the end of segment s then CheckForIntersection (EQ, pred of s, succ of s) delete s from SL else if E is cross event for segments s 1 nd s 2 then println s 1 nd s 2 intersect remove s 1 nd s 2 from SL re insert s 1 nd s 2 into SL in the opposite order CheckForIntersection (EQ, s 1, new neighor of s 1 ) CheckForIntersection (EQ, s 2, new neighor of s 2 ) It s esy to see tht the running time of the lgorithm is O((n + k) log n) using the dt structures descried. Becuse there re O(n+k) events, nd ech one involves constnt numer of opertions on the SL nd EQ dt structures. 3 Counting Intersections of Circles As n exercise, how would you solve the prolem of computing ll the intersections of set of n circles in the plne? We cn gin imgine using plne sweep, wlking verticl line left-to-right cross the plne. We hve the following events: Circle Strt. The leftmost point on circle is reched. We need to strt trcking the circle. 4

5 Circle End. The rightmost point on circle hs een reched. We should stop trcking the circle. Circle Intersect. Output the intersection, nd modify our dt structure to ccount for the intersection. As with the line segment intersection prolem, two intersecting circles will e djcent on the sweep line just efore n intersection. 1 2 A compliction, however, is tht unlike in the line segment cse, we don t hve well-defined ordering of the circles long the sweep line. Prts of circle A cn e ove prts of circle B nd t the sme time prts of circle A cn e elow prts of circle B. But notice tht t ny point in time, the sweep line hits ech circle in t most two plces: the top semicircle nd the ottom semicircle. So, we cn represent ech circle y 2 semicircles. The sketch of the lgorithm is: 1. A priority queue EQ strts with leftmost nd rightmost points of the circles sorted y their x coordinte. As in the point sweep lgorithm, intersection points will e dded to the queue s we go. 2. When we encounter the strt event of circle c, we insert T ophlf(c) nd BottomHlf(c) into our lnced tree SL, keyed y the y coordinte of the strt event point. When we encounter the end event of circle c, we remove these two semicircles. 3. Otherwise, the lgorithm is the sme s for segments: whenever we dd, remove, or swp semicircle, we test its new neighors for intersection. The intersection test is it more complex ecuse we hve to test the intersection of two semicircles (ut you cn work this out on your own). 4 Blloon Pop Prolem: Suppose you re given n non-intersecting circles (lloons) in the plne, where circle i hs rdius r i nd center point q i. Find the line tht will intersect s mny circles s possile. 5

6 q i r i A first try. Note tht we cn lwys find solution tht is tngent some one of the circles: tke solution line nd trnslte it until it ecomes tngent. In fct, we cn lwys find solution tht is tngent to two circles: tke solution line tht is tngent to one circle, nd rotte it until it ecomes tngent to nother circle. Tht leds to n O(n 3 ) lgorithm: for every pir of circles, compute the four tngent lines tht go etween them, nd for ech of those lines, compute (y iterting through the circles) the numer of circles they intersect. Keep nd return the line with the most lloon hits. (This is n exmple of generl strtegy we hve seen efore: reduce prolem with seemingly infinite possile solutions to one with finite numer.) A etter lgorithm. We cn do etter, chieving running time of O(n 2 log n). This lgorithm uses severl plne sweeps of rotting line. We first use the fct tht some optiml line must e tngent to some circle. We guess tht it will e circle C (we ll try ll circles for this role). Every tngent line to C is cndidte, nd ech tngent line is specified y some ngle α. So the ide is to do sweep line, ut insted of moving the line long the x xis, we rotte it round s tngents to the circle C. See figure (): C β 1 α 1 () () As we re sweeping this line, wht re the interesting events? They re when the sweep line first intersects nd then leves (exits) nother circle. For circle i, these occur t ngles (α i,1, β i,1 ) nd (α i,2, β i,2 ), where the first element in ech pir is the entering ngle nd the second element is the corresponding leving ngle. We cn compute ll of these ngles in O(n) time y enumerting through the circles. 6

7 These ngles define intervls on the order of C (corresponding to the rnge of sweep lines tht will hit ech circle): β 1 α 1 C The ngle of gretest depth of coverge y intervls is the tngent line tht hit the lrgest numer of circles. To find this most highly covered ngle, we cn sort the ngles, nd visit them in incresing order. This corresponds to wlking round C. We keep counter depth, which we increment whenever we encounter n entering event, nd we decrement whenever we encounter leving event. We lso trck the mx vlue of the counter (nd corresponding tngent). One lst techniclity: when we strt wlking round the circle C, it my e tht some intervls cross the 0 ngle. To hndle this, we count those explicitly y mking first pss through the intervls (in O(n) time). We strt our depth counter t the numer of intervls tht cross the 0 ngle. To summrize: def MostBlloonPoppingLine(S): for C in S: for every Q in S \ C: compute α Q,1, β Q,1, α Q,2, β Q,2 depth = mx depth = numer of (α, β) intervls crossing ngle 0 L = sorted list of the α, β ngles for ech ngle γ in L: if γ is entering ngle: depth++ if γ is leving ngle: depth if depth > mx depth end mx depth = depth est line for C = γ end if mx depth > glol mx depth: est line = (C, est line for C ) The running time for ech C is O(n) to compute the ngles + O(n log n) to sort the ngles + O(n) to wlk through the ngles to find the mx. We hve to do this ll O(n) times, leding to finl run time of O(n 2 log n). 7

8 4.1 Computing α nd β ngles There re few different cses, ut they cn ll e solved with elementry trigonometry using the fct tht tngent line nd the line connecting the centers of the circles form prt of similr right tringles. Consider the cse t right: the tringle CRA is similr to the tringle QT A. We know the lengths of QT nd CR segments (they re the circle rdii, r Q nd r C ) nd we know the distnce d etween the circle centers. We cn therefore solve for d Q : d Q = r Q = d Q = r Qd d + d Q r C r C r Q when r C r Q (when the rdii re equl, the ngle of the tngent line is just the ngle etween their centers). The ngle QCR cn e computed s: cos 1 r c d + d Q which cn e sutrcted from the ngle 0CQ to otin α 1. The cse where the tngent crosses the CQ line is similr. A d Q Q d T C R α 1 0 8