1 / 33

UMass Lowell Computer Science 91.404 Analysis of Algorithms Prof. Karen Daniels Spring, 2001

UMass Lowell Computer Science 91.404 Analysis of Algorithms Prof. Karen Daniels Spring, 2001. Final Review Mon. 5/14-Wed. 5/16. Overview of Next 2 Lectures. Review of some key course material Final Exam: Course Grade Logistics, Coverage, Format Handout for basis of 40% of test

frey
Download Presentation

UMass Lowell Computer Science 91.404 Analysis of Algorithms Prof. Karen Daniels Spring, 2001

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. UMass Lowell Computer Science 91.404Analysis of AlgorithmsProf. Karen DanielsSpring, 2001 FinalReview Mon. 5/14-Wed. 5/16

  2. Overview of Next 2 Lectures • Review of some key course material • Final Exam: • Course Grade • Logistics, Coverage, Format • Handout for basis of 40% of test • Course Evaluations

  3. Review of Key Course Material

  4. What’s It All About? • Algorithm: • steps for the computer to follow to solve a problem • Problem Solving Goals: • recognize structure of some common problems • understand important characteristics of algorithms to solve common problems • select appropriate algorithm & data structures to solve a problem • tailor existing algorithms • create new algorithms

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

  6. MATH Summations Proofs Sets Growth of Functions Probability Recurrences 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

  7. Discrete Math Review Chapters 1-6 Growth of Functions, Summations, Recurrences, Sets, Counting, Probability

  8. Topics • Discrete Math Review : Chapters 1-6 • Solving Summations & Recurrences • Sets, Basic Tree & Graph concepts • Counting: Permutations/Combinations • Probability: Basics, including Expectation of a Random Variable • Proof Techniques: Induction • Basic Algorithm Analysis Techniques: Chapters 1-6 • Asymptotic Growth of Functions • Types of Input: Best/Average/Worst • Bounds on Algorithm vs. Bounds on Problem • Algorithmic Paradigms/Design Patterns: Divide-and-Conquer • Analyze pseudocode running time to form summations &/or recurrences

  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. n lg(n) 2n 1 lglg(n) lg(n) n n lg2(n) n2 n5 Function Order of Growth O( ) upper bound W( ) lower bound Q( ) upper & lower bound know how to order functions asymptotically (behavior as n becomes large) know how to use asymptotic complexity notation to describe time or space complexity

  11. 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 Best-Case Input Produces Best-Case Running Time provides a lower bound on the algorithm’s asymptotic running time (subject to any implementation assumptions) 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

  12. T(n) = W(1) T(n) = O(2n) very loose bounds are not very useful! n lg(n) 2n 1 lglg(n) lg(n) n n lg2(n) n2 n5 Bounding Algorithmic Time(using cases) 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 Worst-Case time of T(n) = O(2n) 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) = Q(2n ) (i.e. we’ve found the minimum upper bound, so the bound is tight.)

  13. TB (n) = O(n) TW (n) = W(n2) TB(n) = W(1) 1st attempt 1st attempt 1st attempt 1st attempt TB(n) = Q(n) TW(n) = Q(n2) 2nd attempt 2nd attempt Algorithm Bounds n lg(n) 2n 1 lglg(n) lg(n) n n lg2(n) n2 n5 Bounding Algorithmic Time(tightening bounds) for example... TW (n) = O(2n) Here we denote best-case time by TB(n); worst-case time by TW(n)

  14. n4 n5 n 2n n3 1 n2 Approach • Explore the problem to gain intuition: • Describe it: What are the assumptions? (model of computation, etc...) • Has it already been solved? • Have similar problems been solved? (more on this later) • What does best-case input look like? • What does worst-case input look like? • Establish worst-case upper bound on the problem using an algorithm • Design a (simple) algorithm and find an upper bound on its worst-case asymptotic running time; this tells us problem can be solved in a certain amount of time. Algorithms taking more than this amount of time may exist, but won’t help us. • Establish worst-case lower bound on the problem • Tighten each bound to form a worst-case “sandwich” increasing worst-case asymptotic running time as a function of n

  15. 2n 1 n5 No algorithm for the problem exists that can solve it for worst-case inputs in less than linear time . An inefficient algorithm for the problem might exist that takes this much time, but would not help us. n worst-case bounds on problem Know the Difference! Strong Bound: This worst-case lower bound on the problem holds for every algorithm that solves the problem and abides by our problem’s assumptions. Weak Bound: This worst-case upper bound on the 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 are probably loose (i.e. probably can be tightened later on).

  16. Master Theorem Master Theorem : Let with a > 1 and b > 1 . Then : Case 1:If f(n) = O ( n (log b a) - e ) for some e > o then T ( n ) = Q ( n log b a ) Case 2:If f (n) = Q (n log b a ) then T ( n ) = Q (n log b a * log n ) Case 3:If f ( n ) = W (n (log b a) + e ) for some e > o and if a f( n/b) < c f ( n ) for some c < 1 , n > N0 then T ( n ) = Q ( f ( n ) ) Use ratio test to distinguish between cases: f(n)/ n log b a Look for “polynomially larger” dominance.

  17. SortingChapters 7-10 Heapsort, Quicksort, LinearTime-Sorting, Medians

  18. Topics • Sorting: Chapters 7-10 • Sorting Algorithms: • [Insertion & MergeSort from Chapters 1-6)], Heapsort, Quicksort, LinearTime-Sorting, Medians • Comparison-Based Sorting and its lower bound • Breaking the lower bound using special assumptions • Tradeoffs: Selecting an appropriate sort for a given situation • Time vs. Space Requirements • Comparison-Based vs. Non-Comparison-Based

  19. Comparison-Based Sorting Time: BestCase AverageCase WorstCase Algorithm: InsertionSort • W(n lg n) O(n2) MergeSort • W(n lg n) O(n lg n) • Q(n lg n) O(n lg n) Q(n2) QuickSort HeapSort • W(n lg n) O(n lg n) In algebraic decision tree model, comparison-based sorting of n items requiresW(n lg n) time. To breaking the lower bound and obtain linear time, forego direct value comparisons and/or make stronger assumptions about input.

  20. Data StructuresChapters 11-14 Stacks, Queues, LinkedLists, Trees, HashTables, Binary Search Trees, Balanced Trees

  21. Topics • Data Structures: Chapters 11-14 • Abstract Data Types: their properties/invariants • Stacks, Queues, LinkedLists, (Heaps from Chapter 7), Trees, HashTables, Binary Search Trees, Balanced (Red/Black) Trees • Implementation/Representation choices -> data structure • Dynamic Set Operations: • Query [does not change the data structure] • Search, Minimum, Maximum, Predecessor, Successor • Manipulate: [can change data structure] • Insert, Delete • Running Time & Space Requirements for Dynamic Set Operations for each Data Structure • Tradeoffs: Selecting an appropriate data structure for a situation • Time vs. Space Requirements • Representation choices • Which operations are crucial?

  22. Advanced TechniquesChapters 16-17 Dynamic Programming, Greedy Algorithms

  23. Topics • Advanced Techniques: Chapters 16-17 • Algorithmic Paradigms/Design Patterns: • Divide-and-Conquer • Dynamic Programming • Greedy Algorithms • Brute-Force/Naive • Using Dynamic Programming &/or Greedy Algorithms to solve Optimization Problems • Optimal Substructure • Greedy Choice Property: Locally optimal -> Globally optimal • Tradeoffs: • Selecting an appropriate paradigm to solve a problem • Tackling a problem using a sequence of paradigms: • Brute-Force (high running time) then improve...

  24. Problem Characteristics Divide-and-Conquer Dynamic Programming Greedy Algorithms Modular Independent pieces Modular Optimization Optimal substructure: optimal solution contains optimal solutions to subproblems Overlapping subproblems Modular Optimization Optimal substructure: optimal solution contains optimal solutions to subproblems Greedy choice property: locally optimal choices lead to globaloptimum

  25. Graph AlgorithmsChapters 23-25 DFS/BFSTraversals, Topological Sort, MinimumSpanningTrees, Shortest Paths

  26. Topics • Graph Algorithms: Chapters 23-25 • Undirected, Directed Graphs • Connected Components of an Undirected Graph • Representations: Adjacency Matrix, Adjacency List • Traversals: DFS and BFS • Differences in approach: DFS: LIFO/stack vs. BFS:FIFO/queue • Forest of spanning trees • Vertex coloring, Edge classification: tree, back, forward, cross • Shortest paths (BFS) • Topological Sort • Weighted Graphs • MinimumSpanningTrees: 2 different approaches • Shortest Paths: Single source: Dijkstra’s algorithm • Tradeoffs: • Representation Choice: Adjacency Matrix vs. Adjacency List • Traversal Choice: DFS or BFS

  27. Traversals: DFS, BFS • DFS backtracks  visit most recently discovered vertex  LIFO structure  stack data structure • BFS  vertices close to v are visited before those further away  FIFO structure  queue data structure

  28. FINAL EXAM Logistics, Coverage, Format Handout for basis of 40% of test

  29. Course Grading • Homework 40% • Exam 1 15% (closed book) • Midterm 20% (open book) • Final Exam 25% (open book) Results are scaled if necessary. Check grade status with us before final!

  30. Final Exam: Logistics • Friday, 12/18 • Olsen 311: 8:00-11:00 a.m. • Open book, open notes • Closed computers, neighbors • Cumulative • Worth 25% of grade Note change from registrar’s room number

  31. Text/Chapter/Topic Coverage • Discrete Math Review & Basic Algorithm Analysis Techniques : Chapters 1-6 • Summations, Recurrences, Sets, Trees, Graph, Counting, Probability, Growth of Functions, Divide-and-Conquer • Sorting: Chapters 7-10 • Heapsort, Quicksort, LinearTime-Sorting, Medians • Data Structures: Chapters 11-14 • Stacks, Queues, LinkedLists, Trees, HashTables, Binary Search Trees, Balanced (Red/Black) Trees • Advanced Techniques: Chapters 16-17 • Dynamic Programming, Greedy Algorithms • Graph Algorithms: Chapters 23-25 • Traversal, MinimumSpanningTrees, Shortest Paths

  32. Format • Mixture of questions of the following types: 1) Multiple Choice 2) True/False 3) Short Answer 4) Analyze Pseudo-Code and/or Data Structure 5) Solve a Problem by Designing an Algorithm • Select an appropriate paradigm/ design pattern • Select appropriate data structures • Write pseudo-code • Justify correctness • Analyze asymptotic complexity 60% 40%

More Related