Divide-and-Conquer Algorithms

Transcription

1 Divide-and-Conquer Algorithms Divide and Conquer Three main steps Break input into several parts, Solve the problem in each part recursively, and Combine the solutions for the parts Contribution Applicable for those problems that may be split into several parts, and there is an efficient way to combine solutions The original brute-force method is often a polynomial algorithm (e.g., O(n 2 )) A divide-and-conquer method aims to reduce the time complexity (e.g., from O(n 2 ) to O(nlog 2 n)) Also helpful when combined with other algorithmic strategies Computer Algorithms: Lecture 5 1

2 Contents Recurrence analysis for Divide-and-Conquer algorithms Dividing the problem into 2 parts Example: The mergesort algorithm Other variants of problem splitting Example problems that may be solved by Divideand-Conquer Counting inversions Finding the closest pair Integer multiplication More problems to think about Computer Algorithms: Lecture 5 2

3 Recurrence analysis An example: the mergesort algorithm Dividing the original problem into two parts Split: O(1) Combination: O(n) Overall time complexity: O(nlog 2 n) Computer Algorithms: Lecture 5 3

4 Time required for split and Combine: O(n) How many times of split? Log 2 n. [modified from Kleinberg & Tardos, 2006] Computer Algorithms: Lecture 5 4

5 Number of parts: 1; size: n/2; merge: O(n) Time complexity = O(n) Total time required = O(n*[((1/2) log2n -1))/(1/2-1)]) = O(n) [modified from Kleinberg & Tardos, 2006] Computer Algorithms: Lecture 5 5

6 Number of parts: q (q > 2); size: n/2; merge: O(n) Time complexity = O(q log 2n ) = O(n log 2q ) Example: when q=3, O(n log 23 ) = O(n 1.59 ) Total time required = O(n*[((q/2) log2n -1))/(q/2-1)]) = O(q log2n ) = O(n log2q ) We still have Log 2 n times of split! [modified from Kleinberg & Tardos, 2006] Computer Algorithms: Lecture 5 6

7 In summary, when merging requires O(n) time # parts q=1 q=2 q>2 size n/2 O(n) O(nlog 2 n) O(n log 2q ) n/q Infinitive loop O(nlog 2 n) O(nlog q n) When merging requires O(n 2 ) time # parts q=1 q=2 q>2 size n/2 O(n 2 ) O(2n 2 ) O(n log2q ) if q>4 O(4n 2 ) if q<4 n/q Infinitive loop O(2n 2 ) O(qn 2 ) Computer Algorithms: Lecture 5 7

8 Counting inversions The problem Given a sequence of distinct numbers, determine the number of inversions An inversion is a pair of numbers that are out-of-order [modified from Kleinberg & Tardos, 2006] Computer Algorithms: Lecture 5 8

9 The number of inversions smoothly reflect how the given sequence is out of order No inversions, if it is in ascending order (complete agreement) C(n,2) inversions, if it is in descending order (complete disagreement) Application Collaborative filtering Finding which person s preference is similar to yours by comparing his ranking and your ranking Computer Algorithms: Lecture 5 9

10 The algorithm Split Recursive call Merge [modified from Kleinberg & Tardos, 2006] Computer Algorithms: Lecture 5 10

11 [from Kleinberg & Tardos, 2006] O(n) [modified from Kleinberg & Tardos, 2006] Computer Algorithms: Lecture 5 11

12 Finding the closest pair The problem Given n points in the plane, find the pair that is closest together Applications Computer graphics, computer vision, geographic information systems, and even molecular modeling At most, we need to spend O(n 2 ) time There are C(n,2) possible pairs Computer Algorithms: Lecture 5 12

13 The algorithm At most one point in the area O(15n) O(n) [modified from Kleinberg & Tardos, 2006] [modified from Kleinberg & Tardos, 2006] Computer Algorithms: Lecture 5 13

14 Sorting according to the x- and y-coordinates, respectively Trivial case Recursive call Split: Q is the left part, R is the right part (Both have a similar size) At most n points O(1) S includes points from both Q and R We simply consider next 15 points No need to search for neighbors Merge O(nlog 2 n) [modified from Kleinberg & Tardos, 2006] Computer Algorithms: Lecture 5 14

15 Integer multiplication The problem Given two n-digit numbers, find their multiplication O(n 2 ) [from Kleinberg & Tardos, 2006] Computer Algorithms: Lecture 5 15

16 The algorithm (O(n log 23 ) = O(n 1.59 ), because T(n) = 3T(n/2) + cn Split: x 1 (x 0 ) is the higher-order (lower-order) part in base-2 representation of x Recursive call Merge [modified from Kleinberg & Tardos, 2006] Computer Algorithms: Lecture 5 16

17 More problems for you to practice Counting the number of significant inversions As mentioned above, an inversion is a pair i<j such that a i >a j But such kind of inversions may be too sensitive Definition: significant inversion is a pair i<j such that a i >2a j Can you find an O(nlog 2 n) algorithm to count significant inversions? In merging, using an additional pointer to scan for significant inversions? Computer Algorithms: Lecture 5 17

18 Finding the median (i.e. n th smallest value) among 2n numbers There are two databases: one contains n numbers, while the other contains the other n numbers You can only specify a parameter k to query the two databases The database returns the k th number in its database Can you query the databases at most O(log 2 n) times? How to use two queries to reduce the search space from 2n to n? Computer Algorithms: Lecture 5 18

19 Checking equivalent objects Given n bank cards and an equivalence tester, you are asked to check whether there are more than n/2 cards equivalent to each other The equivalence tester accepts two cards, and returns whether they are equivalent to each other Two equivalent cards indicate possible fraud Can you answer the question by performing at most O(nlog 2 n) invocations to the tester? How to merge in O(n)? Can the equivalence class grow when one of the splits has less than one half of equivalent cards? How much time will it need? Computer Algorithms: Lecture 5 19

20 Finding all visible lines from n lines A line is visible if you may see some portion of it from the perspective of y= (i.e. look down) Can you have an O(nlog 2 n) algorithm to do so? For some x 0, a 5 x 0 +b 5 > a j x 0 +b j, for all j 5 L5 is visible. When looking down from the upper view, no portion of L2 may be seen L2 is not visible! [modified from Kleinberg & Tardos, 2006] How to split (by lines or by area)? How to merge in O(n) as in merge sort (keeping only one visible segment for each line, sorted by x-coordinates)? Computer Algorithms: Lecture 5 20

21 Exercise 1 Finding the n th smallest value among 2n numbers The problem is as described in the class Setting n to Randomly generate the numbers Implement two approach Brute-force querying Divide-and-Conquer querying Computer Algorithms: Lecture 5 21

22 Exercise 2 Integer multiplication Randomly generate two integers A and B There are digits (0 ~ 9) in A and B Arrays may be used to store A and B Compute C = A B Using a straightforward brute-force approach Using a divide-and-conquer approach Write a brief report to compare the results from the two approaches Computer Algorithms: Lecture 5 22