1. Divide-and-Conquer Divide: the problem into subproblems
Conquer: solve the subproblems, often by recursion
Combine: the solutions to the subproblems to get the solution for the entire problem.

2. Complexity of Divide-and-Conquer
T(n) = d + a * T(s) + c
cost of dividing = d
cost of combining = c
number of subproblems = a
size of the subproblems = s
(assume subproblems are all approximately the same size).

3. MergeSort(A,left,right)
if (left < right) {
mid = (left + right)/2;
MergeSort(A, left, mid);
MergeSort(A,mid+1,right);
Merge(A,left,mid,right); }

4. Complexity of MergeSort
Cost of Dividing: O(1)
Cost of Combining: Merge, O(n)
Number of Subproblems: 2
Size of Subproblems: n/2
T(1) = 1
T(n) = 1 + 2*T(n/2) + n
T(n) = 2 * T(n/2) + n

5. Solving the Recurrence
T(n) = 2*T(n/2) + n
step2 = 2(2*T(n/4)+n/2)+n = 4T(n/4)+2n
step3 = 4(2*T(n/8)+n/4)+2n= 8T(n/8)+3n
stepk = 2^k T(n/2^k)+kn
when k = log2n; nT(1) + nlog2n
= n + nlog2n  O(nlogn)

6. Homework
Write an algorithm to count the number of inversions in an array (see problem 2-4 Inversions, on page 41).

7. Binary Search(A, n, key) left = 1; right = n;
while (left <= right) {
mid = (left+right)/2;
if (A[mid] < key)
left = mid+1;
else if (A[mid] > key)
right = mid -1;
else return mid;
} return not_found;

8. Binary Search Complexity
Divide = O(1)
Combine = 0
Number of Subproblems = 1
Size of Subproblem: n/2
T(n) = 1 + T(n/2)
Solve: O(logn)

9. Quicksort (A, left, right)
if (right - left > cutoff)
1. Choose a pivot.
2. Move all elements < pivot to the left.
3. Move all elements > pivot to the right.
4. Put the pivot in the correct place.
5. Quicksort(A,left,pivot_pos-1)
6. Quicksort(A,pivot_pos+1,right)

10. Master Method (Ch. 4) T(n) = a * T(n/b) + f(n)
majority of work is done at the top level
complexity is top level complexity
majority of work is done in the leaves
complexity is work at leaves
same amount of work at each level
num_levels * work at each level

11. Master Method (cont) T(n) = a * T(n/b) + f(n)
1. Let p = log (base b) a
2. *Compare n^p and f(n)
Case 1: n^p > f(n). Complexity O(n^p)
Case 2: f(n) > n^p. Complexity O(f(n))
Case 3: f(n) = n^p. Com. O(f(n)*logn)
* a simplification

12. Homework:
From before: problem 1.1 p.13 (could write a short program that zeros in on the correct value. We’ll discuss)… others
Problem 4.1, pg. 85 (not all can use the master method) 4.1(h) is harder.
Problem 2.4: pg. 39,40. a-d.
(to cover in class on Wednesday)

13. Maximum Non-decreasing Subsequence
Input: Array A
Output: The length of the longest non-decreasing sequence in the array.
12,16,2,54,13,7,9,-8,14,13,17,13,15
Answer: Length 6
2,7,9,13,13,15