EXAM ELEMENTARY MATH FOR GMT: ALGORITHM ANALYSIS NOVEMBER 7, 2013, 13:15-16:15, RUPPERT D

Transcription

1 SOLUTIONS EXAM ELEMENTARY MATH FOR GMT: ALGORITHM ANALYSIS NOVEMBER 7, 2013, 13:15-16:15, RUPPERT D This exam consists of 6 questions, worth 10 points in total, and a bonus question for 1 more point. Using a calculator is not allowed, but using the summary is allowed. Put your name and student number on each paper you hand in. An explanation must be part of every answer. Simple or direct answers (such as 42 or yes) will not be given any credit. When you give bounds in O(...), Ω(...), or Θ(...) notation, you must reduce the function as much as possible. In this test, logs are base 2, and arrays are indexed from 1 to n. QUESTION 1: 1 point Prove that the function f(n) = 2n 2 log n 17n + 5 is O(n 2 log n). We need to find c > 0 and n 0 > 0 such that n n 0 we have f(n) cn 2 log n. Choose, for example, c = 3 and n 0 = 5. Then clearly f(n) = 2n 2 log n 17n + 5 < 2n 2 log n + 5 2n 2 log n + n < 3n 2 log n. QUESTION 2: 1 point The Fibonacci numbers F (n) are defined by the recursion F (0) = 0, F (1) = 1, and F (x) = F (x 1) + F (x 2) for x > 1. It is known that F can also be described by the following closed-form formula. F (n) = φn ψ n 5 where φ = and ψ = Prove or disprove that F (n) is Θ(2 n ). F (n) is not Θ(2 n ), because it is not Ω(2 n ). To be Ω(2 n ), there should exist c > 0 and n 0 > 0 such that F (n) > c2 n for all n larger than n 0. However, for any value of c and any n > log( 1 2φ)/ log c we have F (n) < φ n = ( 1 2 φ)n 2 n < c2 n. So, there are no such values c and n 0, so F (n) is not Ω(2 n ). (It is O(2 n ) though.)

2 EXAM ELEMENTARY MATH FOR GMT: ALGORITHM ANALYSIS, NOVEMBER 7, 2013, 13:15-16:15 2 QUESTION 3: The mode of a sequence of numbers is the most frequently occurring number. For example, the mode of 3, 7, 2, 7, 7, 42, 1, 2, 4 is 7. Consider the following algorithm to compute the mode. Input: An array A with n elements. Output: The mode of A. mode 0 count 0 for i 1 to n do m A[i] c 0 for j 1 to n do if A[j] = m then c c + 1 if c > count then mode m count c return mode (a) Analyse the worst case running time of this algorithm in O(...) notation. (b) Give a more efficient algorithm to compute the mode, and analyse its worst case running time in O(...) notation. (a) The algorithm first performs some primitive operations in O(1) time, and then performs a loop over n elements, for each of which it performs some primitive operations in O(1) time and performs another loop over n elements, for each of which it performs some primitive operations. The total running time is O(1) + n (O(1) + n O(1)) = O(n 2 ). (b) If we sort the array first, we only need to make a single pass over the elements. Input: An array A with n elements. Output: The mode of A. mode 0 count 0 m 0 c 0 QuickSort (A) for i 1 to n do if A[i] = m then c c + 1 if c > count then mode m count c m A[i] c 1 return mode The algorithm first performs some primitive operations in O(1) time, then executes QuickSort in O(n log n) time, then performs a loop over n elements, for each of which it performs some primitive operations in O(1) time. The total running time is O(1) + O(n log n) + n O(1) = O(n log n) time.

3 EXAM ELEMENTARY MATH FOR GMT: ALGORITHM ANALYSIS, NOVEMBER 7, 2013, 13:15-16:15 3 QUESTION 4: A binary search is a procedure that searches for a number in a sorted sequence of numbers. The following pseudocode describes a binary search algorithm. Input: A sorted array A with n elements, and an element x. Output: Whether x appears in A or not. if A[1] = x A[n] = x then return true l 1 r n while r > l + 1 do m (l + r)/2 if A[m] = x then return true if A[m] < x then l m if A[m] > x then r m return false (a) Prove that the worst case running time of this algorithm is O(log n). (b) Prove that the worst case running time of this algorithm is Ω(log n). (c) Is it possible that, when running this algorithm, it terminates faster than in logarithmic time? (a) The algorithm performs some primitive operations, and has a single loop, inside of which a constant number of primitive operations are performed. We need to find out how often the loop is executed. For this, consider the quantity w = r l. At the start of the algorithm, r is set to n and l is set to 1, so w = n 1. After each execution of the loop, either l or r is set to (l + r)/2, which means that in the worst case w becomes w/2. When w 1, the loop terminates. So, the number of times the loop is executed is at most log n, and the total running time of the algorithm is O(1) + log n O(1) = O(log n). (b) We need to show that there exists an input on which the algorithm takes at least logarithmic time. Consider for example the sequence A = 1, 2,..., n, and let x = 2. The algorithm will repeatedly set r to (r + 1)/2 until it is 3 or 4, which takes log n time. Therefore, the worst-case running time of the algorithm is Ω(log n). (c) Yes. The worst-case running time of the algorithm is Ω(log n), but there may be inputs on which it runs faster. For example, consider the sequence A = 1, 2,..., n and let x = 1. The algorithm will immediately check whether A[1] = 1, which it is, so it terminates after O(1) time.

4 EXAM ELEMENTARY MATH FOR GMT: ALGORITHM ANALYSIS, NOVEMBER 7, 2013, 13:15-16:15 4 QUESTION 5: Let G be a graph with n vertices. A cycle is a sequence of at least 3 vertices, such that each two consecutive vertices in the sequence are connected by an edge, and the first and last vertex in the sequence are also connected by an edge. (a) Argue that, if G has no cycles, it can have at most O(n) edges. (b) How much storage space do we need to store a graph without cycles in adjacency matrix representation, and how much in adjacency list representation, in Θ(...) notation? (a) Suppose that G has n vertices and at least n edges. Suppose there exists a vertex with only a single neighbour. Then we can remove that vertex and its incident edge, and we are left with a smaller graph that still has at least as many edges as vertices. If we continue to do this, we eventually find a graph in which every vertex has at least two neighbours. In this graph, pick an arbitrary vertex, and start following edges of the graph. Since all vertices have at least two neighbours, we will never find a dead : we can always continue to follow an edge we have not used before, until we reach a vertex that we have already visited before. When that happens, we found a cycle. So, if G has no cycles, it can have at most n 1 edges, which is O(n). (b) In an adjacency matrix, we store a bit of information for each pair of vertices, indepent of whether there is an edge or not, so the storage space required is always Θ(n 2 ). In an adjacency list, the storage is Θ(n + m). For graphs without cycles, m is at most n, as we just proved, so the storage space required is Θ(n). QUESTION 6: (a) Write pseudocode for an algorithm that tests whether a binary search tree T is an AVL tree. (b) Give the worst case running time of your algorithm in O(...) notation. (a) We must test whether T satisfies the balance property of an AVL tree; that is, whether for every node the heights of its two children differ by at most 1. We write a recursive algorithm: testbalance(v) Input: A node v. Output: The height of v and whether the subtree rooted at v is balanced. if v is a dummy then return (0, true) ((h 1, b 1 ) testbalance(v.leftchild) ((h 2, b 2 ) testbalance(v.rightchild) h 1 + max(h 1, h 2 ) b b 1 b 2 ( h 1 h 2 1) return (h, b) Executing the algorithm on the root of the tree will give us the answer (and the height of the tree, which we can ignore). (b) Let n v be the number of nodes in the subtree of T rooted at v. We prove by induction that testbalance(v) takes O(n v ) time. The base case is clearly true: if v is a dummy, the algorithm takes O(1) time. An execution of testbalance(v) performs a constant number of primitive operations, and it recursively calls testbalance on the two children of v. The total time is O(1) + O(n v.leftchild ) + O(n v.rightchild ) = O(1 + n v.leftchild + n v.rightchild ). Because n v = 1 + n v.leftchild + n v.rightchild, the result follows.

5 EXAM ELEMENTARY MATH FOR GMT: ALGORITHM ANALYSIS, NOVEMBER 7, 2013, 13:15-16:15 5 QUESTION 7: 1 bonus point A polygon is a region in the plane bounded by a sequence of points, connected by straight line segments. For example, the sequence (0, 0), (1, 0), (1, 1), (0, 1) describes a square. Suppose you have access to a function area(p, q, r) that computes the area of the triangle formed by three points p, q and r and a function clockwise(p, q, r) that returns true if the triangle is in clockwise order. Write pseudocode for an algorithm that computes the area of a polygon, given as an array with n points, in O(n) time. You may assume that the input is valid (i.e., the segments that connect the points do not cross each other). We can decompose the polygon into triangles, by connecting all vertices to a special point p. If these connections do not cross the edges of the polygon, then the area of the polygon is simply the sum of the areas of the triangles formed by two consecutive points of the polygon and p. When there are intersections, the same algorithm still works if we add or subtract the area of each triangle deping on its orientation, since any area outside the polygon is covered by the same number of triangles in both orientations, so they cancel out in the summation. Input: A polygon, given as an array A of n points. Output: The area of the polygon. result 0 p (0, 0) for i 1 to n 1 do if clockwise(p, A[i], A[i + 1]) then result result + area(p, A[i], A[i + 1]) result result area(p, A[i], A[i + 1]) if clockwise(p, A[n], A[1]) then result result + area(p, A[n], A[1]) result result area(p, A[n], A[1]) return result