1. R. Johnsonbaugh Discrete Mathematics 5 th edition, 2001 Chapter 5 Recurrence Relations

2. 5.1 Introduction A recurrence relation  is an infinite sequence a 1, a 2, a 3,…, a n,…  in which the formula for the nth term a n depends on one or more preceding terms,  with a finite set of start-up values or initial conditions

3. Examples of recurrence relations  Example 1: Initial condition a 0 = 1 Recursive formula: a n = 1 + 2a n-1 for n > 2 First few terms are: 1, 3, 7, 15, 31, 63, …  Example 2: Initial conditions a 0 = 1, a 1 = 2 Recursive formula: a n = 3(a n-1 + a n-2 ) for n > 2 First few terms are: 1, 2, 9, 33, 126, 477, 1809, 6858, 26001,…

4. Fibonacci sequence  Initial conditions: f 1 = 1, f 2 = 2  Recursive formula: f n+1 = f n-1 + f n for n > 3  First few terms: n1234567891011 fnfn 123581321345589144

5. Compound interest  Given P = initial amount (principal) n = number of years r = annual interest rate A = amount of money at the end of n years At the end of:  1 year: A = P + rP = P(1+r)  2 years: A = P + rP(1+r) = P(1+r) 2  3 years: A = P + rP(1+r) 2 = P(1+r) 3 …  Obtain the formula A = P (1 + r) n

6. Towers of Hanoi Start with three pegs numbered 1, 2 and 3 mounted on a board, n disks of different sizes with holes in their centers, placed in order of increasing size from top to bottom.  Object of the game: find the minimum number of moves needed to have all n disks stacked in the same order in peg number 3.

7. Rules of the game: Hanoi towers Start with all disks stacked in peg 1 with the smallest at the top and the largest at the bottom Use peg number 2 for intermediate steps Only a disk of smaller diameter can be placed on top of another disk

8. End of game: Hanoi towers Game ends when all disks are stacked in peg number 3 in the same order they were stored at the start in peg number 1. Verify that the minimum number of moves needed is the Catalan number C 3 = 5. Start End

9. 5.2 Solving recurrence relations Two main methods:  Iteration  Method for linear homogeneous recurrence relations with constant coefficients

10. 5.3 Applications to the analysis of algorithms 1. Selection sorting a) Given a sequence of n terms a k, k = 1, 2,…, n to be arranged in increasing order b) Count the number of comparisons b n with initial condition b 1 = 0 c) Obtain recursion relation b n = n – 1 + b n-1 for n = 1, 2, 3,… d) b n = n(n-1)/2 =  (n 2 )

11. Selection Sort function selection_sort(s,n) begin if( n == 1) return(); max_index = 1 for i = 2 to n if (s[i] > s[max_index] then max_index = i endif endfor swap(s[n], s[max_index]) selection_sort(s, n-1) end

12. Binary search 2. Problem: Search for a value in an increasing sequence. Return the index of the value, or 0 if not found.  Initial condition a 1 = 2  Recurrence relation a n = 1 + a  n/2   Result: a n =  (lg n)

13. Binary_search Function binary_search(s, I, j, key) Begin if( I > j) return(0) endif middle = (i+j) /2 

14. Binary_search (cont.) if( s[middle] = key) then return(middle) if( s[middle] > key) then j = middle -1 else i = middle + 1 endif binary_search( i, j, key) end

15. Merging two sequences 3. Problem: Combine two increasing sequences into a single increasing sequence (merge two sequences).  Theorem 5.3.7: To merge two sequences the sum of whose lengths is n, the number of comparisons required is n-1.

16. Merge Function merge(s, I, m, j, c) Begin p = I q = m+1 r = I

17. Merge while( p <= m and q <= j) if( s[p] < s[q]) c[r] = s[p] p = p+1 else c[r] = s[q] q = q+1 endif r = r+1 endwhile

18. Merge while( p <=m) c[r] = s[p] p = p+1 r = r+1 endwhile while( q <=j) c[r] = s[q] q = q+1 r = r+1 endwhile end

19. Merge sort 4. A recursive algorithm is used to sort a sequence into increasing order using the algorithm for merging two increasing sequences into one increasing sequence (merge sort).  Theorem 5.3.10: The merge sort algorithm is (n lg n) in the worst case.

20. Merge_sort Function merge_sort( s, I, j) Begin if( I =j) return() m =  (i+j) /2  merge_sort(s, I, m) merge_sort( s, m+1, n) merge(s, I, m, j, c)

21. Merge_sort for k = 1 to j s[k] = c[k] endfor end