chapter 4: divide and conquer
DESCRIPTION
The Design and Analysis of Algorithms. Chapter 4: Divide and Conquer. Chapter 4. Divide and Conquer Algorithms. Basic Idea Merge Sort Quick Sort Binary Search Binary Tree Algorithms Closest Pair and Quickhull Conclusion. Basic Idea. - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/1.jpg)
Chapter 4: Divide and Conquer
The Design and Analysis of Algorithms
![Page 2: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/2.jpg)
2
Chapter 4. Chapter 4. Divide and Conquer Algorithms Basic Idea Merge Sort Quick Sort Binary Search Binary Tree Algorithms Closest Pair and Quickhull Conclusion
![Page 3: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/3.jpg)
3
Basic Idea Divide instance of problem into two or
more smaller instances
Solve smaller instances recursively
Obtain solution to original (larger) instance by combining these solutions
![Page 4: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/4.jpg)
4
Basic Idea
subproblem 2 of size n/2
subproblem 1 of size n/2
a solution to subproblem 1
a solution tothe original problem
a solution to subproblem 2
a problem of size n
![Page 5: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/5.jpg)
5
General Divide-and-Conquer Recurrence
T(n) = aT(n/b) + f (n) where f(n) (nd), d 0
Master Theorem: If a < bd, T(n) (nd) If a = bd, T(n) (nd log n) If a > bd, T(n) (nlog b a ) Examples: T(n) = T(n/2) + n T(n) (n )
Here a = 1, b = 2, d = 1, a < bd
T(n) = 2T(n/2) + 1 T(n) (n log 2
2 ) = (n )Here a = 2, b = 2, d = 0, a > bd
![Page 6: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/6.jpg)
6
Examples
T(n) = T(n/2) + 1 T(n) (log(n) )Here a = 1, b = 2, d = 0, a = bd
T(n) = 4T(n/2) + n T(n) (n log 2
4 ) = (n 2 )Here a = 4, b = 2, d = 1, a > bd
T(n) = 4T(n/2) + n2 T(n) (n2 log n)Here a = 4, b = 2, d = 2, a = bd
T(n) = 4T(n/2) + n3 T(n) (n3) Here a = 4, b = 2, d = 3, a < bd
![Page 7: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/7.jpg)
7
Mergesort
Split array A[0..n-1] in two about equal halves and make copies of each half in arrays B and C
Sort arrays B and C recursively
Merge sorted arrays B and C into array A
![Page 8: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/8.jpg)
8
Mergesort
![Page 9: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/9.jpg)
9
Mergesort
![Page 10: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/10.jpg)
10
Mergesort8 3 2 9 7 1 5 4
8 3 2 9 7 1 5 4
8 3 2 9 7 1 5 4
8 3 2 9 7 1 5 4
3 8 2 9 1 7 4 5
2 3 8 9 1 4 5 7
1 2 3 4 5 7 8 9
![Page 11: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/11.jpg)
11
Analysis of Mergesort
All cases have same efficiency: Θ(n log n)
Number of comparisons in the worst case is close to theoretical minimum for comparison-based sorting:
log2 n! ≈ n log2 n - 1.44n
Space requirement: Θ(n) (not in-place)
Can be implemented without recursion (bottom-up)
![Page 12: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/12.jpg)
12
Quicksort Select a pivot (partitioning element) – here, the first
element Rearrange the list so that all the elements in the first s
positions are smaller than or equal to the pivot and all the elements in the remaining n-s positions are larger than or equal to the pivot (see next slide for an algorithm)
Exchange the pivot with the last element in the first (i.e., ) sub-array — the pivot is now in its final position
Sort the two sub-arrays recursively
p
A[i]p
A[i]p
![Page 13: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/13.jpg)
13
Analysis of Quicksort Best case: split in the middle — Θ(n log n) Worst case: sorted array — Θ(n2) Average case: random arrays — Θ(n log n)
Improvements: better pivot selection: median of three partitioning switch to insertion sort on small subfiles elimination of recursion
Quicksort is considered the method of choice for internal sorting of large files (n ≥ 10000)
![Page 14: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/14.jpg)
14
Binary Search Very efficient algorithm for searching in sorted array: K
vsA[0] . . . A[m] . . . A[n-1]
If K = A[m], stop (successful search);
otherwise, continue searching by the same method
in A[0..m-1] if K < A[m],
and in A[m+1..n-1] if K > A[m]
![Page 15: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/15.jpg)
15
Analysis of Binary Search
Time efficiencyWorst-case recurrence: Cw (n) = 1 + Cw( n/2 ), Cw (1) = 1
solution: Cw(n) = log2(n+1)
Optimal for searching a sorted array Limitations: must be a sorted array (not linked list)
![Page 16: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/16.jpg)
16
Binary Tree Algorithms Binary tree is a divide-and-conquer ready structure
Ex. 1: Classic traversals (preorder, inorder, postorder)
Algorithm Inorder(T) if T Inorder(Tleft) print(root of T) Inorder(Tright) Efficiency: Θ(n)
![Page 17: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/17.jpg)
17
Binary Tree Algorithms
Ex. 2: Computing the height of a binary tree
T TL R
h(T) = max{ h(TL), h(TR) } + 1 if T and h() = -1
Efficiency: Θ(n)
![Page 18: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/18.jpg)
18
Closest Pair Problem
Step 1: Divide the points given into two subsets S1 and S2 by a vertical line x = c so that half the points lie to the left or on the line and half the points lie to the right or on the line.
![Page 19: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/19.jpg)
19
Closest Pair Problem Step 2 Find recursively the closest pairs for the left and
right subsets. Step 3 Set d = min {d1, d2} Let C1 and C2 be the subsets of points in the left subset
S1 and of the right subset S2, respectively, that lie in this vertical strip.
The points in C1 and C2 are stored in increasing order of
their y coordinates, which is maintained by merging during the execution of the next step.
Step 4 For every point P(x,y) in C1, we inspect points in C2 that may be closer to P than d. There can be no more than 6 such points (because d ≤ d2)
![Page 20: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/20.jpg)
20
Closest Pair Problem
The worst case scenario is depicted below
![Page 21: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/21.jpg)
21
Efficiency of the Closest Pair Problem
Running time of the algorithm
T(n) = 2T(n/2) + M(n), where M(n) O(n)
By the Master Theorem (with a = 2, b = 2, d = 1) T(n) O(n log n)
![Page 22: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/22.jpg)
22
Quickhull AlgorithmConvex hull: smallest convex set that includes given points Assume points are sorted by x- coordinate values Identify extreme points P1 and P2 (leftmost and
rightmost) Compute upper hull recursively:
find point P max that is farthest away from line P1P2
compute the upper hull of the points to the left of line P1Pmax
compute the upper hull of the points to the left of line PmaxP2
Compute lower hull in a similar manner
![Page 23: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/23.jpg)
23
Quickhull Algorithm
P1
P2
Pmax
![Page 24: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/24.jpg)
24
Efficiency of Quickhull Algorithm
Finding point farthest away from line P1P2 can be done in linear time
Time efficiency: worst case: Θ(n2) (as quicksort)average case: Θ(n ) (under reasonable
assumptions about distribution of points given)
If points are not initially sorted by x-coordinate value, this can be accomplished in O(n log n) time
![Page 25: Chapter 4: Divide and Conquer](https://reader035.vdocuments.us/reader035/viewer/2022062221/56813b43550346895da41953/html5/thumbnails/25.jpg)
25
Conclusion Very efficient solutions. It is the choice when the following is true:
the problem can be described recursively - in terms of smaller
instances of the same problem.
the problem-solving process can be described recursively, i.e.
we can combine the solutions of the smaller instances to
obtain the solution of the original problem
Note that we assume that the problem is split in at least two parts of equal size, not simply decreased by a constant factor.