#### Transcript Chapter 3 - CS Course Webpages

Chapter 3 With Question/Answer Animations Chapter Summary Algorithms Example Algorithms Algorithmic Paradigms Growth of Functions Big-O and other Notation Complexity of Algorithms Section 3.2 Section Summary Big-O Notation Donald E. Knuth (Born 1938) Big-O Estimates for Important Functions Big-Omega and Big-Theta Notation Edmund Landau (1877-1938) Paul Gustav Heinrich Bachmann (1837-1920) The Growth of Functions In both computer science and in mathematics, there are many times when we care about how fast a function grows. In computer science, we want to understand how quickly an algorithm can solve a problem as the size of the input grows. We can compare the efficiency of two different algorithms for solving the same problem. We can also determine whether it is practical to use a particular algorithm as the input grows. We’ll study these questions in Section 3.3. Two of the areas of mathematics where questions about the growth of functions are studied are: number theory (covered in Chapter 4) combinatorics (covered in Chapters 6 and 8) Big-O Notation Definition: Let f and g be functions from the set of integers or the set of real numbers to the set of real numbers. We say that f(x) is O(g(x)) if there are constants C and k such that whenever x > k. (illustration on next slide) This is read as “f(x) is big-O of g(x)” or “g asymptotically dominates f.” The constants C and k are called witnesses to the relationship f(x) is O(g(x)). Only one pair of witnesses is needed. Illustration of Big-O Notation f(x) is O(g(x) Some Important Points about Big-O Notation If one pair of witnesses is found, then there are infinitely many pairs. We can always make the k or the C larger and still maintain the inequality . Any pair C ̍ and k̍ where C < C̍ and k < k ̍ is also a pair of witnesses since whenever x > k̍ > k. You may see “ f(x) = O(g(x))” instead of “ f(x) is O(g(x)).” But this is an abuse of the equals sign since the meaning is that there is an inequality relating the values of f and g, for sufficiently large values of x. It is ok to write f(x) ∊ O(g(x)), because O(g(x)) represents the set of functions that are O(g(x)). Usually, we will drop the absolute value sign since we will always deal with functions that take on positive values. Using the Definition of Big-O Notation Example: Show that is Solution: Since when x > 1, x < x2 and 1 < x2 . Can take C = 4 and k = 1 as witnesses to show that (see graph on next slide) Alternatively, when x > 2, we have 2x ≤ x2 and 1 < x2. Hence, when x > 2. Can take C = 3 and k = 2 as witnesses instead. Illustration of Big-O Notation is Big-O Notation Both and are such that and . We say that the two functions are of the same order. (More on this later) If numbers, then Note that if for all x, then and h(x) is larger than g(x) for all positive real . for x > k and if if x > k. Hence, . For many applications, the goal is to select the function g(x) in O(g(x)) as small as possible (up to multiplication by a constant, of course). Using the Definition of Big-O Notation Example: Show that 7x2 is O(x3). Solution: When x > 7, 7x2 < x3. Take C =1 and k = 7 as witnesses to establish that 7x2 is O(x3). (Would C = 7 and k = 1 work?) Example: Show that n2 is not O(n). Solution: Suppose there are constants C and k for which n2 ≤ Cn, whenever n > k. Then (by dividing both sides of n2 ≤ Cn) by n, then n ≤ C must hold for all n > k. A contradiction! Big-O Estimates for Polynomials Example: Let where are real numbers with an ≠0. Then f(x) is O(xn). Uses triangle inequality, Proof: |f(x)| = |anxn + an-1 xn-1 + ∙∙∙ + a1x1 + a1| an exercise in Section 1.8. ≤ |an|xn + |an-1| xn-1 + ∙∙∙ + |a1|x1 + |a1| Assuming x > 1 = xn (|an| + |an-1| /x + ∙∙∙ + |a1|/xn-1 + |a1|/ xn) ≤ xn (|an| + |an-1| + ∙∙∙ + |a1|+ |a1|) Take C = |an| + |an-1| + ∙∙∙ + |a1|+ |a1| and k = 1. Then f(x) is O(xn). The leading term anxn of a polynomial dominates its growth. Big-O Estimates for some Important Functions Example: Use big-O notation to estimate the sum of the first n positive integers. Solution: Example: Use big-O notation to estimate the factorial function Solution: Continued → Big-O Estimates for some Important Functions Example: Use big-O notation to estimate log n! Solution: Given that (previous slide) then . Hence, log(n!) is O(n∙log(n)) taking C = 1 and k = 1. Display of Growth of Functions Note the difference in behavior of functions as n gets larger Useful Big-O Estimates Involving Logarithms, Powers, and Exponents If d > c > 1, then nc is O(nd), but nd is not O(nc). If b > 1 and c and d are positive, then (logb n)c is O(nd), but nd is not O((logb n)c). If b > 1 and d is positive, then nd is O(bn), but bn is not O(nd). If c > b > 1, then bn is O(cn), but cn is not O(bn). Combinations of Functions If f1 (x) is O(g1(x)) and f2 (x) is O(g2(x)) then ( f1 + f2 )(x) is O(max(|g1(x) |,|g2(x) |)). See next slide for proof If f1 (x) and f2 (x) are both O(g(x)) then ( f1 + f2 )(x) is O(g(x)). See text for argument If f1 (x) is O(g1(x)) and f2 (x) is O(g2(x)) then ( f1 f2 )(x) is O(g1(x)g2(x)). See text for argument Combinations of Functions If f1 (x) is O(g1(x)) and f2 (x) is O(g2(x)) then ( f1 + f2 )(x) is O(max(|g1(x) |,|g2(x) |)). By the definition of big-O notation, there are constants C1,C2 ,k1,k2 such that | f1 (x) ≤ C1|g1(x) | when x > k1 and f2 (x) ≤ C2|g2(x) | when x > k2 . |( f1 + f2 )(x)| = |f1(x) + f2(x)| ≤ |f1 (x)| + |f2 (x)| by the triangle inequality |a + b| ≤ |a| + |b| |f1 (x)| + |f2 (x)| ≤ C1|g1(x) | + C2|g2(x) | ≤ C1|g(x) | + C2|g(x) | where g(x) = max(|g1(x)|,|g2(x)|) = (C1 + C2) |g(x)| = C|g(x)| where C = C1 + C2 Therefore |( f1 + f2 )(x)| ≤ C|g(x)| whenever x > k, where k = max(k1,k2). Ordering Functions by Order of Growth Put the functions below in order so that each function is big-O of the next function on the list. We solve this exercise by successively finding the function that f1(n) = (1.5)n grows slowest among all those left on the list. 3 2 f2(n) = 8n +17n +111 • f (n) = 10000 (constant, does not increase with n) f3(n) = (log n )2 •f (n) = log (log n) (grows slowest of all the others) f4(n) = 2n •f (n) = (log n ) (grows next slowest) f5(n) = log (log n) •f (n) = n (log n) (next largest, (log n) factor smaller than any power of n) 2 3 f6(n) = n (log n) •f (n) = 8n +17n +111 (tied with the one below) n 2 f7(n) = 2 (n +1) •f (n) = n + n(log n) (tied with the one above) •f (n) = (1.5) (next largest, an exponential function) f8(n) = n3+ n(log n)2 •f (n) = 2 (grows faster than one above since 2 > 1.5) f9(n) = 10000 •f (n) = 2 (n +1) (grows faster than above because of the n +1 factor) f10(n) = n! 9 5 2 3 6 2 3 2 8 3 7 2 3 2 n 1 4 3 n n •f10(n) = 3n 2 2 ( n! grows faster than cn for every c) Big-Omega Notation Definition: Let f and g be functions from the set of integers or the set of real numbers to the set of real numbers. We say that if there are constants C and k such that Ω is the upper case version of the lower when x > k. case Greek letter ω. We say that “f(x) is big-Omega of g(x).” Big-O gives an upper bound on the growth of a function, while Big-Omega gives a lower bound. Big-Omega tells us that a function grows at least as fast as another. f(x) is Ω(g(x)) if and only if g(x) is O(f(x)). This follows from the definitions. See the text for details. Big-Omega Notation Example: Show that where Solution: positive real numbers x. Is it also the case that is . for all is ? Big-Theta Notation Θ is the upper case version of the lower case Greek letter θ. Definition: Let f and g be functions from the set of integers or the set of real numbers to the set of real numbers. The function if and . We say that “f is big-Theta of g(x)” and also that “f(x) is of order g(x)” and also that “f(x) and g(x) are of the same order.” if and only if there exists constants C1 , C2 and k such that C1g(x) < f(x) < C2 g(x) if x > k. This follows from the definitions of big-O and big-Omega. Big Theta Notation Example: Show that the sum of the first n positive integers is Θ(n2). Solution: Let f(n) = 1 + 2 + ∙∙∙ + n. We have already shown that f(n) is O(n2). To show that f(n) is Ω(n2), we need a positive constant C such that f(n) > Cn2 for sufficiently large n. Summing only the terms greater than n/2 we obtain the inequality 1 + 2 + ∙∙∙ + n ≥ ⌈ n/2⌉ + (⌈ n/2⌉ + 1) + ∙∙∙ + n ≥ ⌈ n/2⌉ + ⌈ n/2⌉ + ∙∙∙ + ⌈ n/2⌉ = (n − ⌈ n/2⌉ + 1 ) ⌈ n/2⌉ ≥ (n/2)(n/2) = n2/4 Taking C = ¼, f(n) > Cn2 for all positive integers n. Hence, f(n) is Ω(n2), and we can conclude that f(n) is Θ(n2). Big-Theta Notation Example: Sh0w that f(x) = 3x2 + 8x log x is Θ(x2). Solution: 3x2 + 8x log x ≤ 11x2 for x > 1, since 0 ≤ 8x log x ≤ 8x2 . Hence, 3x2 + 8x log x is O(x2). x2 is clearly O(3x2 + 8x log x) Hence, 3x2 + 8x log x is Θ(x2). Big-Theta Notation When Note that it must also be the case that if and only if it is the case that and . Sometimes writers are careless and write as if big-O notation has the same meaning as big-Theta. Big-Theta Estimates for Polynomials Theorem: Let where are real numbers with an ≠0. Then f(x) is of order xn (or Θ(xn)). (The proof is an exercise.) Example: The polynomial is order of x5 (or Θ(x5)). The polynomial is order of x199 (or Θ(x199) ). Section 3.3 Section Summary Time Complexity Worst-Case Complexity Algorithmic Paradigms Understanding the Complexity of Algorithms The Complexity of Algorithms Given an algorithm, how efficient is this algorithm for solving a problem given input of a particular size? To answer this question, we ask: How much time does this algorithm use to solve a problem? How much computer memory does this algorithm use to solve a problem? When we analyze the time the algorithm uses to solve the problem given input of a particular size, we are studying the time complexity of the algorithm. When we analyze the computer memory the algorithm uses to solve the problem given input of a particular size, we are studying the space complexity of the algorithm. The Complexity of Algorithms In this course, we focus on time complexity. The space complexity of algorithms is studied in later courses. We will measure time complexity in terms of the number of operations an algorithm uses and we will use big-O and big-Theta notation to estimate the time complexity. We can use this analysis to see whether it is practical to use this algorithm to solve problems with input of a particular size. We can also compare the efficiency of different algorithms for solving the same problem. We ignore implementation details (including the data structures used and both the hardware and software platforms) because it is extremely complicated to consider them. Time Complexity To analyze the time complexity of algorithms, we determine the number of operations, such as comparisons and arithmetic operations (addition, multiplication, etc.). We can estimate the time a computer may actually use to solve a problem using the amount of time required to do basic operations. We ignore minor details, such as the “house keeping” aspects of the algorithm. We will focus on the worst-case time complexity of an algorithm. This provides an upper bound on the number of operations an algorithm uses to solve a problem with input of a particular size. It is usually much more difficult to determine the average case time complexity of an algorithm. This is the average number of operations an algorithm uses to solve a problem over all inputs of a particular size. Complexity Analysis of Algorithms Example: Describe the time complexity of the algorithm for finding the maximum element in a finite sequence. procedure max(a1, a2, …., an: integers) max := a1 for i := 2 to n if max < ai then max := ai return max{max is the largest element} Solution: Count the number of comparisons. • The max < ai comparison is made n − 2 times. • Each time i is incremented, a test is made to see if i ≤ n. • One last comparison determines that i > n. • Exactly 2(n − 1) + 1 = 2n − 1 comparisons are made. Hence, the time complexity of the algorithm is Θ(n). Worst-Case Complexity of Linear Search Example: Determine the time complexity of the linear search algorithm. procedure linear search(x:integer, a1, a2, …,an: distinct integers) i := 1 while (i ≤ n and x ≠ ai) i := i + 1 if i ≤ n then location := i else location := 0 return location{location is the subscript of the term that equals x, or is 0 if x is not found} Solution: Count the number of comparisons. • At each step two comparisons are made; i ≤ n and x ≠ ai . • To end the loop, one comparison i ≤ n is made. • After the loop, one more i ≤ n comparison is made. If x = ai , 2i + 1 comparisons are used. If x is not on the list, 2n + 1 comparisons are made and then an additional comparison is used to exit the loop. So, in the worst case 2n + 2 comparisons are made. Hence, the complexity is Θ(n). Average-Case Complexity of Linear Search Example: Describe the average case performance of the linear search algorithm. (Although usually it is very difficult to determine average-case complexity, it is easy for linear search.) Solution: Assume the element is in the list and that the possible positions are equally likely. By the argument on the previous slide, if x = ai , the number of comparisons is 2i + 1. Hence, the average-case complexity of linear search is Θ(n). Worst-Case Complexity of Binary Search Example: Describe the time complexity of binary search in terms of the number of comparisons used. procedure binary search(x: integer, a1,a2,…, an: increasing integers) i := 1 {i is the left endpoint of interval} j := n {j is right endpoint of interval} while i < j m := ⌊(i + j)/2⌋ if x > am then i := m + 1 else j := m if x = ai then location := i else location := 0 return location{location is the subscript i of the term ai equal to x, or 0 if x is not found} Solution: Assume (for simplicity) n = 2k elements. Note that k = log n. • Two comparisons are made at each stage; i < j, and x > am . • At the first iteration the size of the list is 2k and after the first iteration it is 2k-1. Then 2k-2 and so on until the size of the list is 21 = 2. • At the last step, a comparison tells us that the size of the list is the size is 20 = 1 and the element is compared with the single remaining element. • Hence, at most 2k + 2 = 2 log n + 2 comparisons are made. • Therefore, the time complexity is Θ (log n), better than linear search. Worst-Case Complexity of Bubble Sort Example: What is the worst-case complexity of bubble sort in terms of the number of comparisons made? procedure bubblesort(a1,…,an: real numbers with n ≥ 2) for i := 1 to n− 1 for j := 1 to n − i if aj >aj+1 then interchange aj and aj+1 {a1,…, an is now in increasing order} Solution: A sequence of n−1 passes is made through the list. On each pass n − i comparisons are made. The worst-case complexity of bubble sort is Θ(n2) since . Worst-Case Complexity of Insertion Sort Example: What is the worst-case complexity of insertion sort in terms of the number of comparisons made? procedure insertion sort(a1,…,an: Solution: The total number of comparisons are: Therefore the complexity is Θ(n2). real numbers with n ≥ 2) for j := 2 to n i := 1 while aj > ai i := i + 1 m := aj for k := 0 to j − i − 1 aj-k := aj-k-1 ai := m Matrix Multiplication Algorithm The definition for matrix multiplication can be expressed as an algorithm; C = A B where C is an m n matrix that is the product of the m k matrix A and the k n matrix B. This algorithm carries out matrix multiplication based on its definition. procedure matrix multiplication(A,B: matrices) for i := 1 to m for j := 1 to n cij := 0 for q := 1 to k cij := cij + aiq bqj return C{C = [cij] is the product of A and B} Complexity of Matrix Multiplication Example: How many additions of integers and multiplications of integers are used by the matrix multiplication algorithm to multiply two n n matrices. Solution: There are n2 entries in the product. Finding each entry requires n multiplications and n − 1 additions. Hence, n3 multiplications and n2(n − 1) additions are used. Hence, the complexity of matrix multiplication is O(n3). Boolean Product Algorithm The definition of Boolean product of zero-one matrices can also be converted to an algorithm. procedure Boolean product(A,B: zero-one matrices) for i := 1 to m for j := 1 to n cij := 0 for q := 1 to k cij := cij ∨ (aiq ∧ bqj) return C{C = [cij] is the Boolean product of A and B} Complexity of Boolean Product Algorithm Example: How many bit operations are used to find A ⊙ B, where A and B are n n zero-one matrices? Solution: There are n2 entries in the A ⊙ B. A total of n Ors and n ANDs are used to find each entry. Hence, each entry takes 2n bit operations. A total of 2n3 operations are used. Therefore the complexity is O(n3) Matrix-Chain Multiplication How should the matrix-chain A1A2∙ ∙ ∙An be computed using the fewest multiplications of integers, where A1 , A2 , ∙ ∙ ∙ , An are m1 m2, m2 m3 , ∙ ∙ ∙ mn mn+1 integer matrices. Matrix multiplication is associative (exercise in Section 2.6). Example: In which order should the integer matrices A1A2A3 - where A1 is 30 20 , A2 20 40, A3 40 10 - be multiplied to use the least number of multiplications. Solution: There are two possible ways to compute A1A2A3. A1(A2A3): A2A3 takes 20 ∙ 40 ∙ 10 = 8000 multiplications. Then multiplying A1 by the 20 10 matrix A2A3 takes 30 ∙ 20 ∙ 10 = 6000 multiplications. So the total number is 8000 + 6000 = 14,000. (A1A2)A3: A1A2 takes 30 ∙ 20 ∙ 40 = 24,000 multiplications. Then multiplying the 30 40 matrix A1A2 by A3 takes 30 ∙ 40 ∙ 10 = 12,000 multiplications. So the total number is 24,000 + 12,000 = 36,000. So the first method is best. An efficient algorithm for finding the best order for matrix-chain multiplication can be based on the algorithmic paradigm known as dynamic programming. (see Ex. 57 in Section 8.1) Algorithmic Paradigms An algorithmic paradigm is a a general approach based on a particular concept for constructing algorithms to solve a variety of problems. Greedy algorithms were introduced in Section 3.1. We discuss brute-force algorithms in this section. We will see divide-and-conquer algorithms (Chapter 8), dynamic programming (Chapter 8), backtracking (Chapter 11), and probabilistic algorithms (Chapter 7). There are many other paradigms that you may see in later courses. Brute-Force Algorithms A brute-force algorithm is solved in the most straightforward manner, without taking advantage of any ideas that can make the algorithm more efficient. Brute-force algorithms we have previously seen are sequential search, bubble sort, and insertion sort. Computing the Closest Pair of Points by Brute-Force Example: Construct a brute-force algorithm for finding the closest pair of points in a set of n points in the plane and provide a worst-case estimate of the number of arithmetic operations. Solution: Recall that the distance between (xi,yi) and (xj, yj) is . A brute-force algorithm simply computes the distance between all pairs of points and picks the pair with the smallest distance. Note: There is no need to compute the square root, since the square of the distance between two points is smallest when the distance is smallest. Continued → Computing the Closest Pair of Points by Brute-Force Algorithm for finding the closest pair in a set of n points. procedure closest pair((x1, y1), (x2, y2), … ,(xn, yn): xi, yi real numbers) min = ∞ for i := 1 to n for j := 1 to i if (xj − xi)2 + (yj − yi)2 < min then min := (xj − xi)2 + (yj − yi)2 closest pair := (xi, yi), (xj, yj) return closest pair The algorithm loops through n(n −1)/2 pairs of points, computes the value (xj − xi)2 + (yj − yi)2 and compares it with the minimum, etc. So, the algorithm uses Θ(n2) arithmetic and comparison operations. We will develop an algorithm with O(log n) worst-case complexity in Section 8.3. Understanding the Complexity of Algorithms Understanding the Complexity of Algorithms Times of more than 10100 years are indicated with an *. Complexity of Problems Tractable Problem: There exists a polynomial time algorithm to solve this problem. These problems are said to belong to the Class P. Intractable Problem: There does not exist a polynomial time algorithm to solve this problem Unsolvable Problem : No algorithm exists to solve this problem, e.g., halting problem. Class NP: Solution can be checked in polynomial time. But no polynomial time algorithm has been found for finding a solution to problems in this class. NP Complete Class: If you find a polynomial time algorithm for one member of the class, it can be used to solve all the problems in the class. P Versus NP Problem Stephen Cook (Born 1939) The P versus NP problem asks whether the class P = NP? Are there problems whose solutions can be checked in polynomial time, but can not be solved in polynomial time? Note that just because no one has found a polynomial time algorithm is different from showing that the problem can not be solved by a polynomial time algorithm. If a polynomial time algorithm for any of the problems in the NP complete class were found, then that algorithm could be used to obtain a polynomial time algorithm for every problem in the NP complete class. Satisfiability (in Section 1.3) is an NP complete problem. It is generally believed that P≠NP since no one has been able to find a polynomial time algorithm for any of the problems in the NP complete class. The problem of P versus NP remains one of the most famous unsolved problems in mathematics (including theoretical computer science). The Clay Mathematics Institute has offered a prize of $1,000,000 for a solution.