Divide-Conquer-Glue Algorithms

Transcription

1 Divide-Conquer-Glue Algorithms Mergesort and Counting Inversions Tyler Moore CSE 3353, SMU, Dallas, TX Lecture 10 Divide-and-conquer. Divide up problem into several subproblems. Solve each subproblem recursively. Combine solutions to subproblems into overall solution. Most common usage. Divide problem of size into two subproblems of size in linear time. Solve two subproblems recursively. Combine two solutions into overall solution in linear time. Some slides created by or adapted from Dr. Kevin Wayne. For more information see Some code reused or adapted from Python Algorithms by Consequence. Brute force: Θ. Divide-and-conquer: Θ. Magnus Lie Hetland. 2 2 / DIVIDE AND CONQUER Problem. Given a list of elements from a totally-ordered universe, rearrange them in ascending order. mergesort counting inversions closest pair of points randomized quicksort median and selection 4 3 / 22 4 / 22

2 Obvious applications. Organize an MP3 library. Display Google PageRank results. List RSS news items in reverse chronological order. Some problems become easier once elements are sorted. Identify statistical outliers. Binary search in a database. Remove duplicates in a mailing list. Non-obvious applications. Convex hull. Closest pair of points. Interval scheduling / interval partitioning. Minimum spanning trees (Kruskal's algorithm). Scheduling to minimize maximum lateness or average completion time Recursively sort left half. Recursively sort right half. Merge two halves to make sorted whole. A L G O R I T H M S A G L O R A G L O R I T H M S H I M S T A G H I L M O R S T 5 / / 22 Canonical Divide-Conquer-Glue Algorithm Goal. Combine two sorted lists and into a sorted whole. Scan and from left to right. Compare and. If, append to (no larger than any remaining element in ). If, append to (smaller than every remaining element in ) def d i v i d e a n d c o n q u e r (S, d i v i d e, g l u e ) : i f l e n ( S ) == 1 : return S L, R = d i v i d e ( S ) A = d i v i d e a n d c o n q u e r ( L, d i v i d e, g l u e ) B = d i v i d e a n d c o n q u e r (R, d i v i d e, g l u e ) return g l u e (A, B) / 22 8 / 22

3 Mergesort in Python How can we measure the time complexity of recursive algorithms? 1 d e f m e r g e s o r t ( seq ) : 2 mid = l e n ( seq )/2 #Midpoint f o r d i v i s i o n 3 l f t, r g t = seq [ : mid ], seq [ mid : ] 4 i f l e n ( l f t ) > 1 : l f t = m e r g e s o r t ( l f t )#S o r t by h a l v e s 5 i f l e n ( r g t ) > 1 : r g t = m e r g e s o r t ( r g t ) 6 r e s = [ ] #Merge s o r t e d h a l v e s 7 w h i l e l f t and r g t : #N e i t h e r h a l f i s empty 8 i f l f t [ 1] >= r g t [ 1 ] : #l f t has g r e a t e s t l a s t v a l u e 9 r e s. append ( l f t. pop ( ) ) #Append i t 10 e l s e : #r g t has g r e a t e s t l a s t v a l u e 11 r e s. append ( r g t. pop ( ) ) #Append i t 12 r e s. r e v e r s e ( ) #R e s u l t i s backward 13 r e t u r n ( l f t or r g t ) + r e s #A l s o add t h e r e m a i n d e r Measuring the time complexity of iterative algorithms is usually straightforward: count the inputs, check for loops, etc. We know that certain operations can take linear time, constant time, logarithmic time, etc. Running those operation in a loop n times produces a multiplicative factor But how can we do this for recursive algorithms? With recurrence relations 9 / / 22 Recurrence Relations Def. = max number of compares to mergesort a list of size. Note. is monotone nondecreasing. Recurrence relations specify the cost of executing recursive functions. Consider mergesort 1 Linear-time cost to divide the lists 2 Two recursive calls are made, each given half the original input 3 Linear-time cost to merge the resulting lists together Recurrence: T (n) = 2T ( n 2 ) + Θ(n) Great, but how does this help us estimate the running time? Mergesort recurrence. Solution. is. Assorted proofs. We describe several ways to prove this recurrence. Initially we assume is a power of and replace with / / 22

4 Proposition. If satisfies the following recurrence, then. Proposition. If satisfies the following recurrence, then. assuming n is a power of 2 assuming n is a power of 2 Pf 1. Pf 2. [by induction on ] Base case: when,. Inductive hypothesis: assume. Goal: show that / / DIVIDE AND CONQUER mergesort counting inversions closest pair of points randomized quicksort median and selection Music site tries to match your song preferences with others. You rank songs. Music site consults database to find people with similar tastes. Similarity metric: number of inversions between two rankings. My rank:. Your rank:. Songs and are inverted if, but. me you A B C D E Brute force: check all Θ pairs / / 22

5 Voting theory. Collaborative filtering. Measuring the "sortedness" of an array. Sensitivity analysis of Google's ranking function. Rank aggregation for meta-searching on the Web. Nonparametric statistics (e.g., Kendall's tau distance). Divide: separate list into two halves and. Conquer: recursively count inversions in each list. Combine: count inversions with and. Return sum of three counts Rank Aggregation Methods for the Web Cynthia Dwork Ravi Kumar Moni Naor D. Sivakumar / / 22 Q. How to count inversions with and? A. Easy if and are sorted! Warmup algorithm. Sort and. For each element, binary search in to find how elements in are greater than. Count inversions with and, assuming and are sorted. Scan and from left to right. Compare and. If, then is not inverted with any element left in. If, then is inverted with every element left in. Append smaller element to sorted list / / 22

6 Input. List. Output. Number of inversions in and sorted list of elements. Proposition. The sort-and-count algorithm counts the number of inversions in a permutation of size in time. Pf. The worst-case running time satisfies the recurrence: Θ Θ / / 22