1 Chapter 5 Divide and Conquer Slides by Kevin Wayne. Copyright © 2005 Pearson-Addison Wesley. All rights reserved.

2 Divide-and-Conquer Divide-and-conquer. n Break up problem into several parts. n Solve each part recursively. n Combine solutions to sub-problems into overall solution. Most common usage. n Break up problem of size n into two equal parts of size ½n. n Solve two parts recursively. n Combine two solutions into overall solution in linear time. Consequence. n Brute force: n 2. n Divide-and-conquer: n log n.

5.1 Mergesort

4 obvious applications problems become easy once items are in sorted order non-obvious applications Sorting Sorting. Given n elements, rearrange in ascending order. Applications. n Sort a list of names. n Organize an MP3 library. n Display Google PageRank results. n List RSS news items in reverse chronological order. n Find the median. n Find the closest pair. n Binary search in a database. n Identify statistical outliers. n Find duplicates in a mailing list. n Data compression. n Computer graphics. n Computational biology. n Supply chain management. n Book recommendations on Amazon. n Load balancing on a parallel computer....

5 Mergesort Mergesort. n Divide array into two halves. n Recursively sort each half. n Merge two halves to make sorted whole. merge sort divide ALGORITHMS ALGORITHMS AGLORHIMST AGHILMORST Jon von Neumann (1945) O(n) 2T(n/2) O(1)

6 Merging Merging. Combine two pre-sorted lists into a sorted whole. How to merge efficiently? n Linear number of comparisons. n Use temporary array. Challenge for the bored. In-place merge. [Kronrud, 1969] AGLORHIMST AGHI using only a constant amount of extra storage

Pseudocode MergeSort (Array(First..Last)) Begin If Array contains only one element Then Return Array Else Middle= ((Last + First)/2) rounded down to the nearest integer LeftHalfArray = MergeSort(Array(First..Middle)) RightHalfArray = MergeSort(Array(Middle+1..Last)) ResultArray = Merge(LeftHalfArray, RightHalfArray) Return ResultArray EndIf End MergeSort 7

8 A Useful Recurrence Relation Def. T(n) = number of comparisons to mergesort an input of size n. Mergesort recurrence. Solution. T(n) = O(n log 2 n). Assorted proofs. We describe several ways to prove this recurrence. Initially we assume n is a power of 2 and replace  with =.

9 Proof by Recursion Tree T(n) T(n/2) T(n/4) T(2) n T(n / 2 k ) 2(n/2) 4(n/4) 2 k (n / 2 k ) n/2 (2)... log 2 n n log 2 n

10 Proof by Telescoping Claim. If T(n) satisfies this recurrence, then T(n) = n log 2 n. Pf. For n > 1: assumes n is a power of 2

11 Proof by Induction Claim. If T(n) satisfies this recurrence, then T(n) = n log 2 n. Pf. (by induction on n) n Base case: n = 1. n Inductive hypothesis: T(n) = n log 2 n. n Goal: show that T(2n) = 2n log 2 (2n). assumes n is a power of 2

12 Analysis of Mergesort Recurrence Claim. If T(n) satisfies the following recurrence, then T(n)  n  lg n . Pf. (by induction on n) n Base case: n = 1. n Define n 1 =  n / 2 , n 2 =  n / 2 . n Induction step: assume true for 1, 2,..., n–1. log 2 n ??

Recurrence Examples Some common cases: T(n) = T(n – 1) + 1 T(n) is O(n) Linear Search T(n) = T(n – 1) + n T(n) is O(n 2 ) QuickSort worst-case T(n) = T(n/2) + 1 T(n) is O(log n) Binary Search T(n) = T(n/2) + n T(n) is O(n) T(n) = 2 T(n/2) + n T(n) is O(n log n) MergeSort T(n) = 2 T(n – 1) T(n) is O(2 n ) 13

5.3 Counting Inversions

15 Music site tries to match your song preferences with others. n You rank n songs. n Music site consults database to find people with similar tastes. n Useful for many social matching, e.g., amazon, netflix, …. Similarity metric: number of inversions between two rankings. n My rank: 1, 2, …, n. n Your rank: a 1, a 2, …, a n. n Songs i and j inverted if i a j. Brute force: check all  (n 2 ) pairs i and j. You Me ABCDE Songs Counting Inversions Inversions 3-2, 4-2

16 Applications Applications. n Voting theory. n Collaborative filtering. n Measuring the "sortedness" of an array. n Sensitivity analysis of Google's ranking function. n Rank aggregation for meta-searching on the Web. n Nonparametric statistics (e.g., Kendall's Tau distance).

17 Counting Inversions: Divide-and-Conquer Divide-and-conquer

18 Counting Inversions: Divide-and-Conquer Divide-and-conquer. n Divide: separate list into two pieces Divide: O(1).

19 Counting Inversions: Divide-and-Conquer Divide-and-conquer. n Divide: separate list into two pieces. n Conquer: recursively count inversions in each half blue-blue inversions8 green-green inversions Divide: O(1). Conquer: 2T(n / 2) 5-4, 5-2, 4-2, 8-2, , 9-3, 9-7, 12-3, 12-7, 12-11, 11-3, 11-7

20 Counting Inversions: Divide-and-Conquer Divide-and-conquer. n Divide: separate list into two pieces. n Conquer: recursively count inversions in each half. n Combine: count inversions where a i and a j are in different halves, and return sum of three quantities blue-blue inversions8 green-green inversions Divide: O(1). Conquer: 2T(n / 2) Combine: ??? 9 blue-green inversions 5-3, 4-3, 8-6, 8-3, 8-7, 10-6, 10-9, 10-3, 10-7 Total = = 22.

21 13 blue-green inversions: Counting Inversions: Combine Combine: count blue-green inversions n Assume each half is sorted. n Count inversions where a i and a j are in different halves. n Merge two sorted halves into sorted whole. Count: O(n) Merge: O(n) to maintain sorted invariant

22

23 Counting Inversions: Implementation Pre-condition. [Merge-and-Count] A and B are sorted. Post-condition. [Sort-and-Count] L is sorted. Sort-and-Count(L) { if list L has one element return 0 and the list L Divide the list into two halves A and B (r A, A)  Sort-and-Count(A) (r B, B)  Sort-and-Count(B) (r B, L)  Merge-and-Count(A, B) return r = r A + r B + r and the sorted list L }

5.4 Closest Pair of Points

25 Closest Pair of Points Closest pair. Given n points in the plane, find a pair with smallest Euclidean distance between them. Fundamental geometric primitive. n Graphics, computer vision, geographic information systems, molecular modeling, air traffic control. n Special case of nearest neighbor, Euclidean MST, Voronoi. Brute force. Check all pairs of points p and q with  (n 2 ) comparisons. 1-D version. O(n log n) easy if points are on a line. Assumption. No two points have same x coordinate. to make presentation cleaner fast closest pair inspired fast algorithms for these problems

26 Closest Pair of Points: First Attempt Divide. Sub-divide region into 4 quadrants. L

27 Closest Pair of Points: First Attempt Divide. Sub-divide region into 4 quadrants. Obstacle. Impossible to ensure n/4 points in each piece. L

28 Closest Pair of Points Algorithm. n Divide: draw vertical line L so that roughly ½n points on each side. L

29 Closest Pair of Points Algorithm. n Divide: draw vertical line L so that roughly ½n points on each side. n Conquer: find closest pair in each side recursively L

30 Closest Pair of Points Algorithm. n Divide: draw vertical line L so that roughly ½n points on each side. n Conquer: find closest pair in each side recursively. n Combine: find closest pair with one point in each side. n Return best of 3 solutions L seems like  (n 2 )

31 Closest Pair of Points Find closest pair with one point in each side, assuming that distance <   = min(12, 21) L

32 Closest Pair of Points Find closest pair with one point in each side, assuming that distance < . n Observation: only need to consider points within  of line L  L  = min(12, 21)

 Closest Pair of Points Find closest pair with one point in each side, assuming that distance < . n Observation: only need to consider points within  of line L. n Sort points in 2  -strip by their y coordinate. L  = min(12, 21)

 Closest Pair of Points Find closest pair with one point in each side, assuming that distance < . n Observation: only need to consider points within  of line L. n Sort points in 2  -strip by their y coordinate. n Only check distances of those within 11 positions in sorted list! L  = min(12, 21)

35 Closest Pair of Points Def. Let s i be the point in the 2  -strip, with the i th smallest y-coordinate. Claim. If |i – j|  12, then the distance between s i and s j is at least . Pf. n No two points lie in same ½  -by-½  box. n Two points at least 2 rows apart have distance  2(½  ). ▪   ½½ 2 rows ½½ ½½ 39 i j

36 Closest Pair Algorithm Closest-Pair(p 1, …, p n ) { Compute separation line L such that half the points are on one side and half on the other side.  1 = Closest-Pair(left half)  2 = Closest-Pair(right half)  = min(  1,  2 ) Delete all points further than  from separation line L Sort remaining points by y-coordinate. Scan points in y-order and compare distance between each point and next 11 neighbors. If any of these distances is less than , update . return . } O(n log n) 2T(n / 2) O(n) O(n log n) O(n)

37 Closest Pair of Points: Analysis Running time. Q. Can we achieve O(n log n)? A. Yes. Don't sort points in strip from scratch each time. n Each recursive returns two lists: all points sorted by y coordinate, and all points sorted by x coordinate. n Sort by merging two pre-sorted lists.