Divide-and-Conquer Algorithms

Transcription

1 Supplment to A Practical Guie to Data Structures an Algorithms Using Java Divie-an-Conquer Algorithms Sally A Golman an Kenneth J Golman Hanout Divie-an-conquer algorithms use the following three phases: Divie the problem into smaller subproblems A subproblem of a problem is a smaller input for the same problem For example, for the problem of computing a closest pair of points, in a subproblem there will be fewer points but the task is still to fin a closest pair of points Generally, the input for the subproblem is a subset of the original input, but that nee not be the case Conquer by recursively solving the subproblems (unless the problem size has reache a specifie termination conition) 3 Combine the solutions to the subproblems to obtain the solution for the original problem To esign a ioe-an-conquer algorithm, you nee to think about what subproblem solution woul be helpful in computing the answer to the original problem While many stuents initially feel like the magic is in the recursion, that step is one that can always be one The real magic is in the combining, an fining the right subproblems to recursively solve We now escribe two sample ivie-an-conquer algorithms Mergesort The problem consiere here is to sort an array a of n comparable elements (a[0],, a[n ]) to be non-ecreasing Mergesort, covere in Section 4 of the text, is one of many algorithms that solve this problem Let s look at how the ivie-an-conquer steps are performe Divie - Split the elements to sort into two equal halves To avoi copying portions of the array, typically the portion of the array being sorte is marke using a start inex p an an en inex r The portion of the array being consiere is a[p],, a[r] So for the initial problem p = 0 an r = n Let q = (p + r)/ Then the problem of sorting a[p],, a[r] is ivie into two subproblems: sort a[p],, a[q] an sort a[q + ],, a[r] Conquer - If either subarray to sort has size then just return Otherwise, recursively sort the subarray Combine - Merge the two sorte subarrays An important component of this algorithm is that merging two sorte subarrays is asymptotically more efficient than sorting the original array In particular, there is a simple linear time algorithm to merge two sorte arrays The etails can be foun on page 47 in the text within the mergesortimpl metho We just cover the intuition here A supplemental array is use to hol the sorte array, which can then be move back into a[p],, a[r] An inex of the current location (initially p) for the left half is maintaine, an inex of the current location (initially q + ) of the right half is maintaine, an an inex of the current location into the supplemental array is maintaine Then the element at the current locations of the left an right halves are compare The smaller of these elements (or either if equal) are move into the next open location in the supplemental array Then the inex of the array from which the element was move is incremente an the inex into the supplemental array is implemente Since constant time is use at each step, an there is one step for each of the elements in the portion of a being sorte, this merge algorithm has linear worst-case asymptotic time complexity For any given problem there can be more than one ivie-an-conquer algorithm Later in this course, we will stuy the quicksort algorithm which is an alternate ivie-an-conquer sorting algorithm that spens linear time iviing the array into subarrays so that no computation is neee to combine

2 Divie-an-Conquer Closest Pair of Points Algorithm We assume that we have a point class, an that points is an array of n references to points We assume that the point class inclues the methos: ist(q) which returns the Eucliean istance between this point an point q leftof(q) which returns true when this point is left of point q This metho is guarantee to orer any points that share the same x-coorinate so as to efine a unique total orering among the points with respect to the x- coorinate By convention, a point is not left of itself below(q) which returns true when this point is below point q As with leftof below efines a unique total orering among the points with respect to the y-coorinate By convention, a point is not below itself The first step of the ivie-an-conquer algorithm is a pre-processing step that both sorts points accoring the the x coorinate, an also sorts points accoring to the y coorinate More specifically, let ptsbyx be an array of references to the points that is sorte using leftof as the comparator, an let ptsbyy be an array of references to the points when sorte using below as the comparator An important invariant that must be maintaine is that for any subproblem that ptsbyx an ptsbyy are permutations of the same set of points We now escribe the ivie-an-conquer algorithm that takes ptsbyx an ptsbyy, an returns the istance between a closest pair of points Let n be the number of points in ptsbyx (which is require by the invariant to also be the number of points in ptsbyy) Divie - Split the set of points into a left half an a right half base on ptsbyx Let x L be the x-coorinate of the rightmost point from the left half, an let x R be the x-coorinate of the leftmost point from the right half As part of the ivie phase, the array of references ptsbyxleft, ptsbyxright, ptsbyyleft, an ptsbyyright must be create This portion of the algorithm can be performe in linear time Think about how that can be one Conquer - The simplest termination conition is to return when n =, an return the istance between the two points when n = When n >, the two subproblems are recursively solve Let L be the istance between the closest pair with input ptsbyxleft, ptsbyyleft, an let R be the istance between the closest pair with input ptsbyxright, ptsbyyright Combine - First compute = min( L, R ) Next create an construct an array ystrip so that it contains all points orere as in ptsbyy such that their x-coorinate is greater than x R an less than x L + (See Figure ) Let numinstrip be the number of points in ystrip Finally, for each point p in ystrip, the istance between p an the next point q in ystrip is compute If the istance between p an q is less than, then is upate to this istance Once the ifference in y-coorinates between p an q reaches, then the istance between p an all remaining points in ystrip must be at least, so p nee not be consiere any further The following loop shows this final step of the combining more explicitly where py is the y coorinate of point p bfor (i = 0; i < numinstrip - ; i++) { j = i+; while (j < numinstrip && ystrip[j]y - ystrip[i]y < ) { = min(, ystrip[j]ist(ystrip[i])); j++; } } Finally can be returne as the istance between the closest pair of points to the given input

3 x R - x L + R = L left subproblem right subproblem x L x R ystrip Correctness Figure : An illustration of the set up for the ivie-an-conquer closest pairs algorithm We now argue that the ivie-an-conquer closest pair algorithm escribe in the last section always yiels the correct answer Let opt be the istance between the closest pair of points in the original input P Let P L be the points in the left subproblem, an let P R be the points in the right subproblem We use the following facts: opt min( L, R ) If opt < min( L, R ) then opt is the istance between a pair of points p P L an p P R 3 For all points p P L, any point p P R that is not in ystrip has a istance from p of at least The reason for this is that the ifference in x-coorinates is at least an so the istance must be at least 4 For all points p P R, any point p P L that is not in ystrip has a istance from p of at least Again, since the ifference in x-coorinates is at least an so the istance must be at least Formally, the correctness argument uses inuction on the number of recursive calls mae The base case is when n = (for which is a correct answer) or when n = (for which case the istance between the two points is the correct answer) We now focus on the inuctive step By the inuctive hypothesis L is the istance between a closest pair of points in P L an R is the istance between a closest pair of points in P R If opt = L then the correct answer is returne since is set to min( L, R ) an will only be change if a closer pair is foun Likewise, if opt = R then the correct answer is returne 3

4 portion of ystrip p All points in left half in the shae region are at least apart All points in right half in the shae region are at least apart Figure : The region that hols all points for which a istance computation is performe when p is being consiere We now consier when opt < min( L, R ) From facts, 3, an 4 above it follows that this can only occur if opt is the istance between points p P L ystrip an p P R ystrip So all we have left to prove is that the istance between points p an p is compute in the combine step Observe that since the points in ystrip are sorte by y-coorinate, once the ifference in y-coorinates is it will remain for the remaining points in ystrip Since the ifference in y-coorinates is so is the istance Thus each point in ystrip is compare to all points above it with a ifference of y-coorinate less than Since p an p have a istance less than, their ifference in y-coorinate must be less than Thus istance between p an p will be compute an after that upate to = opt an cannot be change further since there is no closer pair Analysis Let n be the size of the original problem, an let T (s) be the worst-case time complexity to solve a problem of size s Let f (s) be the worst-case time for the ivie step for a problem of size s, an let f (s) be the worst-case time for the combine step for a problem of size s For the mergesort algorithm f (s) is a constant (ie, inepenent of s) an f (s) is linear (that is f (s) c s for some constant c) When properly implemente, for the ivie-an-conquer closest pair algorithm, f (s) is linear We now argue that for each point p consiere in the combining step, the number of istance computations mae for it is constant Figure illustrates all points consiere in the while loop when p = ystrip[i] It is easily shown that at most 7 such points can fit in the shae region Since constant computation is use for each point, f (s) is also linear Thus for both mergesort an the ivie-an-conquer closest pair algorithm, f (s) + f (s) c s for some constant c Our goal is to compute T (n), the asymptotic time complexity for each of these algorithms for an input of size n Unlike the brute-force closest pair algorithm, it is less clear how to compute the overall time complexity because it is not known how long each recursive call takes However, observe that for the original problem of size n, T (n/) is the asymptotic time complexity for solving the left subproblem an T (n/) is the asymptotic time complexity for solving the right subproblem So we can a together both the cost of iviing an combining (f (s) + f (s)) with the cost for the 4

5 n level 0 # noes time per noe cn n/ n/ c(n/) n/4 n/4 n/4 n/4 4 4 i 4 i (log n) - n/4 c(n/4) c(n/ i ) 4c (log n) - n/ leaves (when recursion terminates) Figure 3: A recursion tree for the recurrence equation T (n) = T (n/) + cn for n > an T () = recursive calls (T (n/) + T (n/)) = T (n/)) to create the following recurrence equation T (n) = for all n T (n) = T (n/) + cn for all n > since it takes one statement (or if you prefer constant time) when the termination conition is reache, an T (n/)+cn time otherwise Appenix B6 of the text gives a cook-book metho to solve this Crecurrence Here, we will solve it from scratch using a recursion tree uner the assumption that n is a power of In a recursion tree we unfol the recursion to show (abstractly) every recursive call mae In computing the time complexity, the important thing about each recursive call is the problem size, so that is all we show in Figure 3 The total time spent for all recursive calls (except the termination steps) is the sum of the ivie/combine times for each subproblem with size greater than For the original problem of size n, cn time is spent oing the ivie an combine steps There are subproblems of size n/ an each spen cn/ time oing the ivie an combine steps Thus the total ivie/combine time for the problems of size n/ is cn Likewise, there are 4 problems of size n/4 each with a ivie/combine time cn/4 for a total time of cn, an so on Observe that the sequence 4, 8,, n has (log n) elements in it So the total time spent performing the ivie an combine steps across the entire execution is cn(log n ) Finally there are n/ pairs consiere in the termination step, for which n/ statements are execute So the total number of statements execute is at most cn log n cn + n/ = cn log n n(c /) which grows asymptotically as n log n Finally, for the closest-pair algorithm by using mergesort for the pre-processing the total time for the entire algorithm grows asymptotically as n log n 5