EECS 311: Chapter 2 Notes Chris Riesbeck EECS Northwestern

 Unless otherwise noted, all tables, graphs and code from Mark Allen Weiss' Data Structures and Algorithm Analysis in C++, 3 rd ed, copyright © 2006 by Pearson Education, Inc.

Maximal Subsequence Sum Problem  Given a sequence of N positive and negative integers A 1, A 2, A 3, …, A n  Find the subsequence A j, … Ak with the largest sum  Example: -2, 11, -4, 13, -5,

Triple-Loop Algorithm For every start point For every end point Add up the subsequence Save the biggest

Algorithm 1 Run-Times

Double-Loop Algorithm For every start point For every end point New sum is old sum + next item Save the biggest

Algorithm 2 Run-Times

Divide and Conquer Algorithm Sum for 1 element subsequence Sums for max subsequences in left and right halves Sum for max left subsequence ending on center Sum for max right subsequence starting right of center Return largest of the 3 sums

Analysis of Algorithm 3 To derive T(N), time to solve a problem with N items Base case T(1) = O(1) Recursive case T(N) = 2T(N/2) +… … O(N) + … … O(1)

Analyzing Divide and Conquer  T(1) = O(1)  T(N) = 2T(N/2) + N T(2) = 2T(1) + 2 = 4 = 2*2 T(4) = 2T(2) + 4 = 12 = 4*3 T(8) = 2T(4) + 8 = 32 = 8*4 T(16) = 2T(8) + 16 = 80 = 16*5  T(2 k ) = 2 k * (k+1)  For general N, O(N log N)

Algorithm 3 Run-Times

Single-Loop Algorithm For every start point New sum is old sum + next item If bigger, save; if negative, forget and start over

Algorithm 4 Run-Times

Algorithmic Analysis

Run-times for small N

Run-times for large N

Typical Growth Rates Don't confuse with log log N which is < log N

Binary Search Does this algorithm always stop? If it does, does it always return the right answer? If it does, how long does it take, in the worst case?

Does it halt?  Find a measure M such that you can prove it monotonically decrease on every iteration the algorithm halts when M passes some threshold, e.g., 0  Binary search example: M = high – low M decreases by at least 1 every iteration algorithm halts when M < 0

Does it give the right answer?  Proof by cases When it returns a value, is it correct (no false positives)? When it returns not found, is it correct (no false negatives)?

When it returns a value, is it correct ?  Proof by contradiction: Assume desired property is false. Prove contradiction results.  Binary search example: Assume k ≠ -1 is returned and a[k] ≠ x. k is returned on line 19. This means a[k] is neither > nor < than x. a[k] must be or =. Contradiction.

When it returns not found, is it correct ?  Proof by induction: Prove P is true for K, typically 1 or 2 Prove P is true for N+1 if it’s true for N Then P is true for all N ≥ K  Binary search example: Assume x not in a[]. Assume a[] has 1 element.  a[0] ≠ x and code correctly returns not found. Assume a[] has N + 1 elements.  Proof by cases: If a[mid] < x, search will look at a[mid] … a[high], which has less than N elements. By assumption, that search returns correct answer. Similarly if a[mid] > x. Ergo, binary search returns not found correctly for all N ≥ 1

Greatest Common Divisor Does this algorithm always stop? If it does, does it always return the right answer? If it does, how long does it take, in the worst case?

Exponentiation Does this algorithm always stop? If it does, does it always return the right answer? If it does, how long does it take, in the worst case?

Hailstone Numbers void printHailStones(int n) { cout << n << ":"; while (n > 1) { cout << " " << n; if ( n % 2 == 0 ) n /= 2; else n = 3 * n + 1; } cout << " " << n << endl; } Does this algorithm always stop? If it does, does it always return the right answer? If it does, how long does it take, in the worst case?