File Organization and Processing Week 13 Divide and Conquer

2 A Technique for designing algorithm that decompose instance into smaller subinstances of the same problem –Solving the sub-instances independently –Combining the sub-solutions to obtain the solution of the original instance

3 Divide and Conquer Basic Steps: –Divide: the problem into a number of subproblems that are themselves smaller instances of the same type of problem. –Conquer: Recursively solving these subproblems. If the subproblems are small enough, solve them straightforward. –Combine: the solutions to the subproblems into the solution of original problem.

4 Most common usage Break up problem of size n into two equal parts of size n/2. Solve two parts recursively Combine two solutions into overall solution in linear time.

5 Sort Obviously application –Sort a list of names. – Organize an MP3 library. – Display Google PageRank results. – List RSS news items in reverse chronological order. Problems become easy once items are in sorted order –Find the median. –Find the closest pair. –Binary search in a database. –Identify statistical outliers. –Find duplicates in a mailing list.

6 Applications Non-obvious applications –Data compression. –Computer graphics. –Computational biology. –Supply chain management. –Book recommendations on Amazon. –Load balancing on a parallel computer. –....

7 Merge-Sort Review Merge-sort on an input sequence S with n elements consists of three steps: –Divide: partition S into two sequences S 1 and S 2 of about n  2 elements each –Recur: recursively sort S 1 and S 2 –Conquer: merge S 1 and S 2 into a unique sorted sequence Algorithm mergeSort(S, C) Input sequence S with n elements, comparator C Output sequence S sorted according to C if S.size() > 1 (S 1, S 2 )  partition(S, n/2) mergeSort(S 1, C) mergeSort(S 2, C) S  merge(S 1, S 2 )

8 Merge Sort John von Neumann MERGE-SORT A[1.. n] 1.If n = 1, done. 2.Recursively sort A[ 1..  n/2  ] and A[  n/2  +1.. n ]. 3.“Merge” the 2 sorted lists. Key subroutine: “Merge” Divide Conquer Combine

9 Merging two sorted arrays

10 Merging two sorted arrays

11 Merging two sorted arrays

12 3 Merging two sorted arrays

13 3 Merging two sorted arrays

Merging two sorted arrays

Merging two sorted arrays

Merging two sorted arrays

17 43 Merging two sorted arrays

18 43 Merging two sorted arrays

19 43 Merging two sorted arrays Time =  (n) to merge a total of n elements (linear time).

20 Analyzing merge sort M ERGE -S ORT A[1.. n] 1.If n = 1, done. 2.Recursively sort A[ 1..  n/2  ] and A[  n/2  +1.. n ]. 3.“Merge” the 2 sorted lists T(n)  (1) 2T(n/2)  (n)

21 Recurrence Equation Analysis The conquer step of merge-sort consists of merging two sorted sequences, each with n  2 elements and implemented by means of a doubly linked list, takes at most bn steps, for some constant b. Likewise, the basis case ( n < 2) will take at b most steps. Therefore, if we let T(n) denote the running time of merge-sort: We can therefore analyze the running time of merge-sort by finding a closed form solution to the above equation. –That is, a solution that has T(n) only on the left-hand side.

22 Iterative Substitution In the iterative substitution, or “plug-and-chug,” technique, we iteratively apply the recurrence equation to itself and see if we can find a pattern: Note that base, T(n)=b, case occurs when 2 i =n. That is, i = log n. So, Thus, T(n) is O(n log n).

23 The Recursion Tree Draw the recursion tree for the recurrence relation and look for a pattern: depthT’ssize 01n 12 n2n2 i2i2i n2in2i ……… time bn … Total time = bn + bn log n (last level plus all previous levels)

24 Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant.

25 Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. T(n)T(n)

26 Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. T(n/2) cn

27 Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn T(n/4) cn/2

28 Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn cn/4 cn/2  (1) …

29 Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn cn/4 cn/2  (1) … h = lg n

30 Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn cn/4 cn/2  (1) … h = lg n cn

31 Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn cn/4 cn/2  (1) … h = lg n cn

32 Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn cn/4 cn/2  (1) … h = lg n cn …

33 Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn cn/4 cn/2  (1) … h = lg n cn #leaves = n (n)(n) …

34 Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn cn/4 cn/2  (1) … h = lg n cn #leaves = n (n)(n) Total  (n lg n) …