# Algorithm Design Strategy Divide and Conquer. More examples of Divide and Conquer ï±...

date post

19-Dec-2015Category

## Documents

view

219download

0

Embed Size (px)

### Transcript of Algorithm Design Strategy Divide and Conquer. More examples of Divide and Conquer ï±...

- Slide 1
- Algorithm Design Strategy Divide and Conquer
- Slide 2
- More examples of Divide and Conquer Review of Divide & Conquer Concept More examples Finding closest pair of points Quicksort Matrix Multiplication Algorithm Large Integer Multiplication
- Slide 3
- Divide and Conquer Approach Concept: D&C is a general strategy for algorithm design. It involves three steps: (1) Divide an instance of a problem into one or more smaller instances (2) Conquer (solve) each of the smaller instances. Unless a smaller instance is sufficiently small, use recursion to do this (3) If necessary, combine the solutions to the smaller instances to obtain the solution to the original instances (e.g., Mergesort) Approach: - Recursion (Top-down approach)
- Slide 4
- Example 1: Binary Search Binary search in a sorted array with size n Worst case time complexity in the recursive binary search: W(n) = W(n/2) + 1 W(1) = 1 Solve the recurrence, and obtain: W(n) = lg(n) +1 (lg n)
- Slide 5
- Example 2: Closest Pair Problem Finding the closest pair of points - Find the closest pair of points in a set of points. The set consists of points in two dimension plane - Given a set P of N points, find p, q P, such that the distance d(p, q) is minimum - Application: - traffic control systems: A system for controlling air or sea traffic might need to know which two vehicles are too close in order to detect potential collisions. - computational geometry
- Slide 6
- Brute force algorithm Input: set S of points Output: closest pair of points min_distance = infinity for each point x in S for each point y in S if x y and distance(x,y) < min_distance { min_distance = dist(x,y) closest_pair = (x,y) } Time Complexity: O(n 2 )
- Slide 7
- 1 Dimension Closest Pair Problem Brute-force algorithm: Find all the distances D(p, q) and find the minimum distance Time complexity: O(n 2 ) 1D problem can be solved in O(nlgn) via sorting But, sorting does not generalize to higher dimensions Lets develop a divide & conquer algorithm for 2D problem.
- Slide 8
- 2D Closest Pair Problem Finding the closest pair of points - The "closest pair" refers to the pair of points in the set that has the smallest Euclidean distance, Distance between points p1=(x1,y1) and p2=(x2,y2) - If there are two identical points in the set, then the closest pair distance in the set will obviously be zero.
- Slide 9
- 2D Closest Pair Problem Finding the closest pair of points - Divide: Sort the points by x-coordinate; draw vertical line to have roughly n/2 points on each side -Conquer: Find closest pair in each side recursively -Combine: Find closest pair with one point in each side -Return: best of three solutions
- Slide 10
- Example 2 Find the closest pair in a strip of width 2d Example: d= min(12, 21)
- Slide 11
- 2D Closest Pair p d d d d d S1 S2 d = minimum (d Lmin, d Rmin ) For each point p on the left of the dividing line, we have to compare to the distances to the points in the blue rectangle. Note there must be no point inside the blue rectangle, because d = minimum (dLmin, dRmin). Thus, for each point p, we only have to consider 6 points 6 red circles on the blue rectangles. So, we need at most 6*n/2 distance comparisons Dividing Line
- Slide 12
- 2D Closest Pair Time Complexity T(n) = 2T(n/2) + O(n) = O(nlgn) Solve this recurrence equation yourself by applying the iterative method
- Slide 13
- Example 3: Quicksort quicksort(L) { if (length(L) < 2) return L else { pick some x in L // x is the pivot element L1 = { y in L : y < x } L2 = { y in L : y > x } L3 = { y in L : y = x } quicksort(L1) quicksort(L2) return concatenation of L1, L3, and L2 } Source: http://www.ics.uci.edu/~eppstein/161/960118.htmlhttp://www.ics.uci.edu/~eppstein/161/960118.html
- Slide 14
- Time Complexity of Quicksort T(n) = T(n 1 ) + T(n 2 ) + n-1 n 1 = length of L 1, n 2 = length of L 2 n 1 + n 2 = n 1 if all the elements in L are unique Best case L is divided into two halves at every recursion T(n) = 2T(n/2) + n-1 = (nlgn) Worst case T(n) = T(0) + T(n-1) + n-1 when the pivot is always the smallest, i.e., L is already sorted So, T(n) = (n 2 ) Why is it called quicksort?
- Slide 15
- How to make Quicksort efficient Randomization Randomly pick an element in L as the pivot So, each item has the same probability of 1/n to be selected as the pivot Avoid the worst case shown in the previous slide
- Slide 16
- Time Complexity of Randomized Quicksort O(nlgn) Proof by Induction Refer to http://www.cs.binghamton.edu/~kang/teaching/cs333/rqsort.pdf http://www.cs.binghamton.edu/~kang/teaching/cs333/rqsort.pdf
- Slide 17
- Example 4: Strassen s matrix multiplication algorithm Example: 2 by 2 matrix multiplication m1 = (a11 + a22)(b11+b22) m2 = (a21 + a22) b11 m3 = a11 (b12 b22) m4 = a22 (b21 b11) m5 = (a11 + a12) b22 m6 = (a21 a11) (b11+b12) m7 = (a12 a22)(b21 + b22)
- Slide 18
- Example 4 (cont d) Strassen s matrix multiplication algorithm - partition n*n matrix into sub-matrices n/2 * n/2 (assume n is power of 2) - apply the seven basic calculations: M1 = (A11 + A22)(B11+B22) M2 = (A21 + A22) B11 M3 = A11 (B12 B22) M4 = A22 (B21 B11) M5 = (A11 + A12) B22 M6 = (A21 A11) (B11+B12) M7 = (A12 A22)(B21 + B22)
- Slide 19
- Example 4 (cont d) Strassen s matrix multiplication example
- Slide 20
- Example 4 (cont d) What if n is no power of 2? Add sufficient number of rows and columns of 0s More sophisticated approaches
- Slide 21
- Example 4 (cont d) Strassen s matrix multiplication: input: n, A, B; output: C strassen_matrix_multiply(int n, A, B, C) { divide A into A11, A12, A21, A22; divide B into B11, B12, B21, B22; strassen_matrix_multiply(n/2, A11+A22, B11+B22, M1); strassen_matrix_multiply(n/2, A21+A22, B11, M2); strassen_matrix_multiply(n/2, A12-A22, B21+B22, M7); Compose C11, , C22 by M1, , M7; }
- Slide 22
- Example 4 (cont d) Strassen s matrix multiplication algorithm - Every case Time complexity Multiplications: T(n) = 7 T(n/2); T(1) = 1 T(n) = n lg7 (n 2.81 ) (while brute-force approach: T(n)= (n 3 ) Additions/Subtractions: T(n) = 7 T(n/2) + 18 (n/2) 2 T(1) = 0 T(n) = 6n lg7 6n 2 O(n 2.81 )
- Slide 23
- Example 4 (cont d) Strassen s matrix multiplication algorithm - Proof of Time complexity Multiplications: T(n) = 7 T(n/2); T(1) = 1 Guess solution: T(n) = 7 lgn Induction base: n=1 T(1) = 7 lg1 = 1 Induction hypothesis: T(n) = 7 lgn Induction step: T(2n)= 7T(2n/2)=7*7 lgn =7 lg(2n) So the guess solution is true! Note: 7 lgn = n lg7 n 2.18
- Slide 24
- Example 5: Large Integer Multiplication Large digits are divided into a number of small digits - u v u = x 10 m + y v = w 10 m + z u v = xw 10 2m + (xz + wy) 10 m + yz (split integer (u, v) into two equal size integers (x, y), (w, z)) e.g., 123456 = 123 *10^3 +456. 123 and 456 all have 3 digits. Worst-case time complexity W(n) = 4 W(n/2) + cn W(n) (n 2 )
- Slide 25
- Example 5 (contd) In the previous solution, we need 4 multiplications xw, xz + yw, and yz; Observe that: r = (x+y)(w+z) = xw + (xz+yw) + yz xz + yw = r xw yz So, just compute (x+y)(w+z), xw, and yz 3 multiplications T(n) = 3T(n/2) + cn (n 1.58 )
- Slide 26
- Combine the D&C algorithm with other simple algorithm Switching point - Recursive method may not show the advantage in the case of small n as compared to the alternative algorithms - Recursive algorithm requires a fair amount of overhead. - We need to determine for what value of n it is at least as fast to call an alternative algorithm as it is to divide the instance further. - The dividing process is stopped in a certain switching point (or threshold) for recursive algorithm, and then is switched to the alternative algorithm Example - Use the standard matrix multiplication to multiply two 2 *2 matrices
- Slide 27
- When not to use D&C algorithm Two cases: - An instance of size n is divided into two or more instances each almost of size n, e.g., Recursive Fibonacci term is O(2 n ), while the iterative one is O(n) - An instance of size n is divided into almost n instances of size n/c (c is constant)

Recommended

*View more*