Download presentation

Presentation is loading. Please wait.

1
5 - 1 § 5 The Divide-and-Conquer Strategy e.g. find the maximum of a set S of n numbers

2
5 - 2 time complexity: assume n = 2 k T(n) = 2T(n/2)+1 = 2(2T(n/4)+1)+1 = 4T(n/4)+2+1 : =2 k-1 T(2)+2 k-2 +…+4+2+1 =2 k-1 +2 k-2 +…+4+2+1 =2 k -1 = n-1

3
5 - 3 A general divide-and-conquer algorithm Step 1: If the problem size is small, solve this problem directly; otherwise, split the original problem into 2 sub-problems with equal sizes. Step 2: Recursively solve these 2 sub-problems by applying this algorithm. Step 3: Merge the solutions of the 2 sub-problems into a solution of the original problem.

4
5 - 4 time complexity: where S(n): time for splitting M(n): time for merging b: a constant c: a constant.

5
5 - 5 Binary search e.g. 2 4 5 6 7 8 9 search 7: needs 3 comparisons time: O(log n) The binary search can be used only if the elements are sorted and stored in an array.

6
5 - 6 Algorithm Binary-Search Input: A sorted sequence of n elements stored in an array. Output: The position of x (to be searched). Step 1: If only one element remains in the array, solve it directly. Step 2: Compare x with the middle element of the array. Step 2.1: If x = middle element, then output it and stop. Step 2.2: If x < middle element, then recursively solve the problem with x and the left half array. Step 2.3: If x > middle element, then recursively solve the problem with x and the right half array.

7
5 - 7 Algorithm BinSearch(a, low, high, x) // a[]: sorted sequence in nondecreasing order // low, high: the bounds for searching in a [] // x: the element to be searched // If x = a[j], for some j, then return j else return – 1 if (low > high) then return – 1 // invalid range if (low = high) then // if small P if (x == a[i]) then return i else return -1 else // divide P into two smaller subproblems mid = (low + high) / 2 if (x == a[mid]) then return mid else if (x < a[mid]) then return BinSearch(a, low, mid-1, x) else return BinSearch(a, mid+1, high, x)

8
5 - 8 quicksort e.g. sort into nondecreasing order [26 5 37 1 61 11 59 15 48 19] [26 5 19 1 61 11 59 15 48 37] [26 5 19 1 15 11 59 61 48 37] [11 5 19 1 15] 26 [59 61 48 37] [11 5 1 19 15] 26 [59 61 48 37] [ 1 5] 11 [19 15] 26 [59 61 48 37] 1 5 11 15 19 26 [59 61 48 37] 1 5 11 15 19 26 [59 37 48 61] 1 5 11 15 19 26 [48 37] 59 [61] 1 5 11 15 19 26 37 48 59 61

9
5 - 9 Algorithm Quicksort Input: A set S of n elements. Output: the sorted sequence of the inputs in nondecreasing order. Step 1: If |S| 2, solve it directly Step 2: (Partition step) Use a pivot to scan all elements in S. Put the smaller elements in S 1, and the larger elements in S 2. Step 3: Recursively solve S 1 and S 2.

10
5 - 10 time in the worst case: (n-1)+(n-2)+...+1 = = O(n 2 ) n(n-1) 2 time in the best case: In each partition, the problem is always divided into two subproblems with almost equal size.... log 2 n n × 2 = n n 2 × 4 = n n 4

11
5 - 11 T(n): time required for sorting n elements T(n) ≦ cn+2T(n/2), for some constant c. ≦ cn+2(c ． n/2 + 2T(n/4)) ≦ 2cn + 4T(n/4) ≦ cnlog 2 n + nT(1) = O(nlogn)...

12
5 - 12 merge sort two-way merge: [25 37 48 57][12 33 86 92] [12 25 33 37 48 57 86 92] merge time complexity: O(m+n), m and n: lengths of the two sorted lists merge sort (nondecreasing order) [25][57][48][37][12][92][86][33] [25 57][37 48][12 92][33 86] [25 37 48 57][12 33 86 92] [12 25 33 37 48 57 86 92] pass 1 pass 2 pass 3 log 2 n passes are required. time complexity: O(nlogn)

13
5 - 13 Algorithm Merge-Sort Input: A set S of n elements. Output: the sorted sequence of the inputs in nondecreasing order. Step 1: If |S| 2, solve it directly Step 2: Recursively apply this algorithm to solve the leaf half part and right half part of S, and the results are stored in S 1 and S 2, respectively. Step 3: Perform the two-way merge scheme on S 1 and S 2.

14
5 - 14 2-D maxima finding problem Def: A point (x 1, y 1 ) dominates (x 2, y 2 ) if x 1 > x 2 and y 1 > y 2. A point is called a maxima if no other point dominates it.

15
5 - 15 Straightforward method: compare every pair of points time complexity: O(n 2 ). The maximal of S L and S R

16
5 - 16 Algorithm Maximal-Points Input: A set S of n planar points. Output: The maximal points of S. Step 1: If |S|=1, return it as the maxima. Otherwise, find a line L perpendicular to the X-axis which separates S into two subsets S L and S R with equal size. Step 2: Recursively find the maximal points of S L and S R. Step 3: Find the largest y-value of S R, denoted as y max. Conduct a linear scan on the maximal points of S L and discard each one if its y-value is less than y max. Time complexity: T(n) = O(n log n)

17
5 - 17 The closest pair problem Given a set S of n points, find a pair of points which are closest together. 1-D version: solved by sorting time: O(n log n) 2-D version:

18
5 - 18 at most 6 points in rectangle A:

19
5 - 19 Algorithm Closest-Pair Input: A set S of n points in the plane. Output: The distance between two closest points. Step 1. Sort points in S according to their y-values and x-values. Step 2. If S contains only one point, return as its distance. Step 3. Find a median line L perpendicular to the X-axis to divide S into two subsets, with equal sizes, S L and S R. Every point in S L lies to the left of L and every point in S R lies to the right of L. Step 4. Recursively apply Step 2 and Step 3 to solve the closest pair problems of S L and S R. Let d L (d R ) denote the distance between the closest pair in S L (S R ). Let d = min(d L, d R ).

20
5 - 20 Step 5. Project all points within the slab bounded by L-d and L+d onto the line L. For a point P in the half-slab bounded by L-d and L, Let its y-value by denoted as y P. For each such P, find all points in the half-slab bounded by L and L+d whose y-value fall within y P +d and y P -d. If the distance d between P and a point in the other half-slab is less than d, let d=d. The final value of d is the answer. time complexity: O(n log n) Step 1: O(n log n) Steps 2~5: T(n) = O(n log n)

21
5 - 21 The convex hull problem concave polygon: convex polygon: The convex hull of a set of planar points is the smallest convex polygon containing all of the points.

22
5 - 22 the divide-and-conquer strategy to solve the problem: Step 1: Select an interior point p. Step 2: There are 3 sequences of points which have increasing polar angles with respect to p. (1) g, h, i, j, k (2) a, b, c, d (3) f, e Step 3: Merge these 3 sequences into 1 sequence: g, h, a, b, f, c, e, d, i, j, k.

23
5 - 23 Step 4: Apply Graham scan to examine the points one by one and eliminate the points which cause reflexive angles. e.g. points b and f need to be deleted. Final result:

24
5 - 24 Algorithm Convex Hull Input: A set S of planar points Output: A convex hull for S Step 1. If S contains no more than five points, use exhaustive searching to find the convex hull and return. Step 2. Find a median line perpendicular to the X-axis which divides S into S L and S R ; S L lies to the left of S R. Step 3. Recursively construct convex hulls for S L and S R. Denote these convex hulls by Hull(S L ) and Hull(S R ) respectively. Step 4. Find an interior point P of S L. Find the vertices v 1 and v 2 of Hull(S R ) which divide the vertices of Hull(S R ) into two sequences of vertices which have increasing polar angles with respect to P. Without loss of generality, let us assume that v 1 has greater y- value than v 2.

25
5 - 25 Then form three sequences as follows: a)Sequence 1: all of the convex hull vertices of Hull(S L ) in counterclockwise direction. b)Sequence 2: the convex hull vertices of Hull(S R ) from v 2 to v 1 in counter-clockwise direction. c)Sequence 3: the convex hull vertices of Hull(S R ) from v 2 to v 1 in clockwise direction. Merge these three sequences and conduct the Graham scan. Eliminate the points which are reflexive and the remaining points from the convex hull. time complexity: T(n) = 2T(n/2) + O(n) = O(n log n)

26
5 - 26 Strassen’s matrix multiplication Let A, B and C be n n matrices C = AB C(i, j) = A(i, k)B(k, j) The straightforward method to perform a matrix multiplication requires O(n 3 ) time. The divide-and-conquer strategy:

27
5 - 27 Time complexity: (# of additions: n 2 ) T(n) = O(n 3 ) Strassen’s method: P = (A 11 + A 22 )(B 11 + B 22 ) Q = (A 21 + A 22 )B 11 R = A 11 (B 12 - B 22 ) S = A 22 (B 21 - B 11 ) T = (A 11 + A 12 )B 22 U = (A 21 - A 11 )(B 11 + B 12 ) V = (A 12 - A 22 )(B 21 + B 22 ) C 11 = P + S - T + V C 12 = R + T C 21 = Q + S C 22 = P + R - Q + U

28
5 - 28 7 multiplications and 18 additions or subtractions. time complexity:

29
5 - 29 The Fast Fourier Transform (FFT) Fourier transform: Inverse Fourier transform: Discrete Fourier transform (DFT): given a 0, a 1, …, a n-1, compute

30
5 - 30 Inverse DFT: DFT can be computed in O(n 2 ) time by a straightforward method. DFT can be solved by the divide-and-conquer strategy (FFT, Fast Fourier Transform) in O(nlogn) time.

31
5 - 31 The FFT method e.q. n=4, w=e i2 π /4, w 4 =1, w 2 =-1 b 0 =a 0 +a 1 +a 2 +a 3 b 1 =a 0 +a 1 w+a 2 w 2 +a 3 w 3 b 2 =a 0 +a 1 w 2 +a 2 w 4 +a 3 w 6 b 3 =a 0 +a 1 w 3 +a 2 w 6 +a 3 w 9 another form: b 0 =(a 0 +a 2 )+(a 1 +a 3 ) b 2 =(a 0 +a 2 w 4 )+(a 1 w 2 +a 3 w 6 ) =(a 0 +a 2 )-(a 1 +a 3 ) When we calculate b 0, we shall calculate (a 0 +a 2 ) and (a 1 +a 3 ). Later, b 2 van be easily calculated. Similarly, b 1 =(a 0 + a 2 w 2 )+(a 1 w+a 3 w 3 ) =(a 0 -a 2 )+w(a 1 -a 3 ) b 3 =(a 0 +a 2 w 6 )+(a 1 w 3 +a 3 w 9 ) =(a 0 -a 2 )-w(a 1 -a 3 ).

32
5 - 32 e.g. n=8, w=e i2 π /8, w 8 =1, w 4 =-1 b 0 =a 0 +a 1 +a 2 +a 3 +a 4 +a 5 +a 6 +a 7 b 1 =a 0 +a 1 w+a 2 w 2 +a 3 w 3 +a 4 w 4 +a 5 w 5 +a 6 w 6 +a 7 w 7 b 2 =a 0 +a 1 w 2 +a 2 w 4 +a 3 w 6 +a 4 w 8 +a 5 w 10 +a 6 w 12 +a 7 w 14 b 3 =a 0 +a 1 w 3 +a 2 w 6 +a 3 w 9 +a 4 w 12 +a 5 w 15 +a 6 w 18 +a 7 w 21 b 4 =a 0 +a 1 w 4 +a 2 w 8 +a 3 w 12 +a 4 w 16 +a 5 w 20 +a 6 w 24 +a 7 w 28 b 5 =a 0 +a 1 w 5 +a 2 w 10 +a 3 w 15 +a 4 w 20 +a 5 w 25 +a 6 w 30 +a 7 w 35 b 6 =a 0 +a 1 w 6 +a 2 w 12 +a 3 w 18 +a 4 w 24 +a 5 w 30 +a 6 w 36 +a 7 w 42 b 7 =a 0 +a 1 w 7 +a 2 w 14 +a 3 w 21 +a 4 w 28 +a 5 w 35 +a 6 w 42 +a 7 w 49 b 0 =(a 0 +a 2 +a 4 +a 6 )+(a 1 +a 3 +a 5 +a 7 ) b 1 =(a 0 +a 2 w 2 +a 4 w 4 +a 6 w 6 )+ w(a 1 +a 3 w 2 +a 5 w 4 +a 7 w 6 ) b 2 =(a 0 +a 2 w 4 +a 4 w 8 +a 6 w 12 )+ w 2 (a 1 +a 3 w 4 +a 5 w 8 +a 7 w 12 ) b 3 =(a 0 +a 2 w 6 +a 4 w 12 +a 6 w 18 )+ w 3 (a 1 +a 3 w 6 +a 5 w 12 +a 7 w 18 ) b 4 =(a 0 +a 2 +a 4 +a 6 )-(a 1 +a 3 +a 5 +a 7 ) b 5 =(a 0 +a 2 w 2 +a 4 w 4 +a 6 w 6 )-w(a 1 +a 3 w 2 +a 5 w 4 +a 7 w 6 ) b 6 =(a 0 +a 2 w 4 +a 4 w 8 +a 6 w 12 )-w 2 (a 1 +a 3 w 4 +a 5 w 8 +a 7 w 12 ) b 7 =(a 0 +a 2 w 6 +a 4 w 12 +a 6 w 18 )-w 3 (a 1 +a 3 w 6 +a 5 w 12 +a 7 w 18 )

33
5 - 33 rewrite as: b 0 =c 0 +d 0 b 4 =c 0 -d 0 =c 0 +w 4 d 0 b 1 =c 1 +wd 1 b 5 =c 1 -wd 1 =c 1 +w 5 d 1 b 2 =c 2 +w 2 d 2 b 6 =c 2 -w 2 d 2 =c 2 +w 6 d 2 b 3 =c 3 +w 3 d 3 b 7 =c 3 -w 3 d 3 =c 3 +w 7 d 3 c 0 =a 0 +a 2 +a 4 +a 6 c 1 =a 0 +a 2 w 2 +a 4 w 4 +a 6 w 6 c 2 =a 0 +a 2 w 4 +a 4 w 8 +a 6 w 12 c 3 =a 0 +a 2 w 6 +a 4 w 12 +a 6 w 18 Let x=w 2 =e i2 π /4 c 0 =a 0 +a 2 +a 4 +a 6 c 1 =a 0 +a 2 x+a 4 x 2 +a 6 x 3 c 2 =a 0 +a 2 x 2 +a 4 x 4 +a 6 x 6 c 3 =a 0 +a 2 x 3 +a 4 x 6 +a 6 x 9 Thus, {c 0,c 1,c 2,c 3 } is FFT of {a 0,a 2,a 4,a 6 }. Similarly, {d 0,d 1,d 2,d 3 } is FFT of {a 1,a 3,a 5,a 7 }.

34
5 - 34 In general, let w=e i2 π /n (assume n is even.) w n =1, w n/2 =-1 b j =a 0 +a 1 w j +a 2 w 2j +…+a n-1 w (n-1)j, ={a 0 +a 2 w 2j +a 4 w 4j +…+a n-2 w (n-2)j }+ w j {a 1 +a 3 w 2j +a 5 w 4j +…+a n-1 w (n-2)j } =c j +w j d j b j+n/2 =a 0 +a 1 w j+n/2 +a 2 w 2j+n +a 3 w 3j+3n/2 +… +a n-1 w (n-1)j+n(n-1)/2 =a 0 -a 1 w j +a 2 w 2j -a 3 w 3j +…+a n-2 w (n-2)j -a n-1 w (n-1)j =c j -w j d j =c j +w j+n/2 d j

35
5 - 35 Algorithm Fast Fourier Transform Input: a 0, a 1, …, a n-1, n = 2 k Output: b j, j=0, 1, 2, …, n-1 where Step 1. If n=2, compute b 0 = a 0 + a 1, b 1 = a 0 - a 1, and return. Step 2. Recursively find the Fourier transform of {a 0, a 2, a 4, …, a n-2 } and {a 1, a 3, a 5, …,a n-1 }, whose results are denoted as {c 0, c 1, c 2, …, c n/2-1 } and {d 0, d 1, d 2, …, d n/2- 1 }.

36
5 - 36 Step 3. Compute b j : b j = c j + w j d j for 0 j n/2 - 1 b j+n/2 = c j - w j d j for 0 j n/2 - 1. time complexity: T(n) = 2T(n/2) + O(n) = O(n log n)

37
5 - 37 An application of the FFT polynomial multiplication {b 0, b 1, …, b n-1 } is the DFT of {a 0, a 1, …, a n-1 }. {a 0, a 1, …, a n-1 } is the inverse DFT of {b 0, b 1, …, b n-1 }. Polynomial multiplication: The straightforward product requires O(n 2 ) time.

38
5 - 38 A fast polynomial multiplication: Step 1: Let N be the smallest integer that N=2 q and N 2n-1. Step 2: Compute FFT of {a 0, a 1, …, a n-1, 0, 0, …, 0} N Step 3: Compute FFT of {c 0, c 1, …, c n-1, 0, 0, …, 0} N Step 4: Compute f(w j ) g(w j ), j=0, 1, …, N-1, where w=e i2 /N

39
5 - 39 Step 5: h(w j )=f(w j )g(w j ) Compute inverse DFT of {h(w 0 ), h(w 1 ), …, h(w N-1 )}. The resulting sequence of numbers are the coefficients of h(x). details in Step5: Let h(x)=b 0 + b 1 x+ b 2 x 2 + …+ b N-1 x N-1 {b 0, b 1, b 2, …, b N-1 } is the inverse DFT of {h(w 0 ), h(w 1 ), …, h(w N-1 )}. {h(w 0 ), h(w 1 ), …, h(w N-1 )} is the DFT of {b 0, b 1, b 2, …, b N-1 }, and h(w j )=f(w j )g(w j ). time: O(NlogN)=O(nlogn), N<4n.

Similar presentations

© 2020 SlidePlayer.com Inc.

All rights reserved.

To make this website work, we log user data and share it with processors. To use this website, you must agree to our Privacy Policy, including cookie policy.

Ads by Google