1. UMass Lowell Computer Science 91.404 Analysis of Algorithms Prof. Karen Daniels Spring, 2002 Lecture 1 Introduction/Overview Text: Chapters 1, 2 Thurs. 1/24/02

2. Web Page http://www.cs.uml.edu/~kdaniels/courses/ALG_404.html Web Page

3. Nature of the Course ä Core course: required for all CS majors ä Advanced undergraduate level ä Graduate students take separate course (91.503) ä No programming required ä “Pencil-and-paper” exercises ä Lectures supplemented by: ä Programs ä Real-world examples

4. What’s It All About? ä Algorithm: ä steps for the computer to follow to solve a problem ä well-defined computational procedure that transforms input into output ä Some of our goals: ä recognize structure of some common problems ä understand important characteristics of algorithms to solve common problems ä select appropriate algorithm to solve a problem ä tailor existing algorithms ä create new algorithms

5. Some Algorithm Application Areas Computer Graphics Geographic Information Systems Robotics Bioinformatics Astrophysics Medical Imaging Telecommunications Design Apply Analyze

6. Some Typical Problems Sorting Input: Set of items Problem: Arrange items “in order” Median finding Input: Set of numbers or keys Problem: Find item smaller than half of items and bigger than half of items SOURCE: Steve Skiena’s Algorithm Design Manual (for problem descriptions, see graphics gallery at ) (for problem descriptions, see graphics gallery at http://www.cs.sunysb.edu/~algorith) Minimum Spanning Tree Input: Graph G = (V,E) with weighted edges Problem: Find subset of E of G of minimum weight which forms a tree on V Shortest Path Input: Edge-weighted graph G, with start vertex and end vertex t Problem: Find the shortest path from to t in G

7. Tools of the Trade ä Algorithm Design Patterns such as: ä binary search ä divide-and-conquer ä Data Structures such as: ä trees, linked lists, hash tables, graphs ä Theoretical Computer Science principles such as: ä NP-completeness, hardness Growth of Functions Summations Recurrences Sets Probability MATH Proofs Logarithms Permutations Combinations

8. Tools of the Trade: (continued) Algorithm Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html

9. What are we measuring? ä Some Analysis Criteria: ä Scope ä The problem itself? ä A particular algorithm that solves the problem? ä “Dimension” ä Time Complexity? Space Complexity? ä Type of Bound ä Upper? Lower? Both? ä Type of Input ä Best-Case? Average-Case? Worst-Case? ä Type of Implementation ä Choice of Data Structure

10. Prerequisites ä Computing I (91.101) ä Computing II (91.102) ä Discrete Math I & II (92.321, 92.322) ä Statistics for Scientists and Engineers (92.386) ä Calculus I-III (92.131-231) Growth of Functions Summations Recurrences Sets Probability MATH Proofs Logarithms Permutations Combinations

11. Course Structure: 5 Parts ä Foundations ä Analyzing & Designing Algorithms, Growth of Functions, Recurrences, Probability & Randomized Algorithms ä Sorting ä Heapsort, Priority Queues, Quicksort, Sorting in Linear Time, Medians and Order Statistics ä Data Structures ä Stacks and Queues, Linked Lists, Introduction to Trees, Hash Tables, Binary Search Trees, Balancing Trees: Red- Black Trees ä Advanced Techniques ä Dynamic Programming, Greedy Algorithms ä Graph Algorithms ä DFS, BFS, Topological Sort, MST, Shortest paths

12. Textbook - - Required: ä Introduction to Algorithms ä by T.H. Corman, C.E. Leiserson, R.L. Rivest ä McGraw-Hill ä 2001 ä ISBN 0-07-013151-1 ä see course web site (MiscDocuments) for errata (1 st edition) Ordered for UML bookstore New Edition

13. Syllabus (current plan) - - See course web site

14. CS Theory Math Review Sheet The Most Relevant Parts... ä p. 1  O, ,  definitions ä Series ä Combinations ä p. 2 Recurrences & Master Method ä p. 3 ä Probability ä Factorial ä Logs ä Stirling’s approx ä p. 4 Matrices ä p. 5 Graph Theory ä p. 6 Calculus ä Product, Quotient rules ä Integration, Differentiation ä Logs ä p. 8 Finite Calculus ä p. 9 Series Math fact sheet (courtesy of Prof. Costello) is on our web site.

15. Important Dates ä Midterm Exam : Thursday, 3/14 ä Midterm Exam (Chapters 1-7) : Thursday, 3/14 ä Final Exam:TBA

16. Grading ä ä Homework35% ä ä Midterm (Chapters 1-7) 30% (open book, notes ) ä ä Final Exam35% (open book, notes )

17. Homework 1 Th, 1/24 Tues, 2/5 Chapters 1, 2 HW# Assigned Due Content

18. Text Chapters 1, 2

19. Sorting ä Sorting Problem: ä Input: A sequence of n numbers ä Output: A permutation (reordering) of the input sequence such that: instance ä Algorithm: ä well-defined computational procedure that transforms input into output ä steps for the computer to follow to solve a problem

20. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Finding a place for item with value 5 in position 1: Finding a place for item with value 5 in position 1: Swap item in position 0 with item in position 1.

21. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Positions 0 through 1 are now in non-decreasing order.

22. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Finding a place for item with value 1 in position 2: Finding a place for item with value 1 in position 2: Swap item in position 1 with item in position 2.

23. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Finding a place for item with value 1: Finding a place for item with value 1: Swap item in position 0 with item in position 1. Positions 0 through 2 are now in non-decreasing order.

24. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Finding a place for item with value 3 in position 3: Finding a place for item with value 3 in position 3: Swap item in position 2 with item in position 3.

25. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Finding a place for item with value 3: Finding a place for item with value 3: Swap item in position 1 with item in position 2.

26. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Positions 0 through 3 are now in non-decreasing order.

27. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Finding a place for item with value 2 in position 4: Finding a place for item with value 2 in position 4: Swap item in position 3 with item in position 4.

28. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Finding a place for item with value 2: Finding a place for item with value 2: Swap item in position 2 with item in position 3.

29. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Finding a place for item with value 2: Finding a place for item with value 2: Swap item in position 1 with item in position 2.

30. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Positions 0 through 4 are now in non-decreasing order.

31. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Finding a place for item with value 6 in position 5: Finding a place for item with value 6 in position 5: Swap item in position 4 with item in position 5.

32. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Positions 0 through 5 are now in non-decreasing order.

33. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Finding a place for item with value 4 in position 6: Finding a place for item with value 4 in position 6: Swap item in position 5 with item in position 6.

34. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Finding a place for item with value 4: Finding a place for item with value 4: Swap item in position 4 with item in position 5.

35. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Positions 0 through 6 are now in non-decreasing order.

36. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Finding a place for item with value 7 in position 7: Finding a place for item with value 7 in position 7: Swap item in position 6 with item in position 7.

37. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Positions 0 through 7 are now in non-decreasing order.

38. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Positions 0 through 7 are now in non-decreasing order.

39. Insertion Sort Animation http://www.cs.brockport.edu/cs/java/apps/sorters/insertsortaniminp.html Positions 0 through 7 are now in non-decreasing order.

40. Asymptotic Notation courtesy of Prof. Costello O(g(n)) is a set of functions, so we often say f(n) is in O(g(n)).

41. Asymptotic Notation (cont.) courtesy of Prof. Costello

42. Asymptotic Analysis Math fact sheet (courtesy of Prof. Costello) is on our web site.

43. Function Order of Growth O( ) upper bound  ( ) lower bound  ( ) upper & lower bound n 1 n lg(n) n lg 2 (n) 2n2n2n2n n5n5n5n5 lg(n) lg(n)lglg(n) n2n2n2n2 know how to use asymptotic complexity notation to describe time or space complexity know how to order functions asymptotically (behavior as n becomes large)

44. Types of Algorithmic Input Best-Case Input: of all possible algorithm inputs of size n, it generates the “best” result for Time Complexity: “best” is smallest running time for Time Complexity: “best” is smallest running time Best-Case Input Produces Best-Case Running Time Best-Case Input Produces Best-Case Running Time provides a lower bound on the algorithm’s asymptotic running time provides a lower bound on the algorithm’s asymptotic running time (subject to any implementation assumptions) (subject to any implementation assumptions) for Space Complexity: “best” is smallest storage for Space Complexity: “best” is smallest storage Average-Case Input Worst-Case Input these are defined similarly Best-Case Time <= Average-Case Time <= Worst-Case Time

45. Bounding Algorithmic Time (using cases) n 1 n lg(n) n lg 2 (n) 2n2n2n2n n5n5n5n5 lg(n) lg(n)lglg(n) n2n2n2n2 T(n) =  (1) T(n) =  (2 n ) very loose bounds are not very useful! Worst-Case time of T(n) =  (2 n ) tells us that worst-case inputs cause the algorithm to take at most exponential time (i.e. exponential time is sufficient). But, can the algorithm every really take exponential time? (i.e. is exponential time necessary?) If, for arbitrary n, we find a worst-case input that forces the algorithm to use exponential time, then this tightens the lower bound on the worst-case running time. If we can force the lower and upper bounds on the worst-case time to match, then we can say that, for the worst-case running time, T(n) =  ( 2 n ) (i.e. we’ve found the minimum upper bound, so the upper bound is tight.) Using “case” we can discuss lower and/or upper bounds on: best-case running time or average-case running time or worst-case running time

46. Bounding Algorithmic Time (tightening bounds) n 1 n lg(n) n lg 2 (n) 2n2n2n2n n5n5n5n5 lg(n) lg(n)lglg(n) n2n2n2n2 T B (n) =  (1) T W (n) =  (2 n ) for example... 1st attempt T B (n) =  (n) 1st attempt 2nd attempt T W (n) =  (n 2 ) Here we denote best-case time by T B (n); worst-case time by T W (n) T B (n) =  (n) 2nd attempt 1st attempt T W (n) =  (n 2 ) Algorithm Bounds

47. Know the Difference!  (n) 1 2n2n2n2n O(n 5) worst-case bounds on problem on problem An inefficient algorithm for the problem might exist that takes this much time, but would not help us. No algorithm for the problem exists that can solve it for worst-case inputs in less than linear time. Strong Bound: A worst- case lower bound on a problem holds for every algorithm that solves the problem and abides by the problem’s assumptions. Weak Bound: A worst-case upper bound on a problem comes from just considering one algorithm. Other, less efficient algorithms that solve this problem might exist, but we don’t care about them! Both the upper and lower bounds could be loose (i.e. perhaps could be tightened later on).