Question 1 (45 points)

Transcription

1 COMP Homework #3 Solution Mathieu Blanchette Question 1 (45 points) /* This methods takes as argument an operator and two Integer operands * and evaluates the expression and return its value */ static Integer apply(string operator, Integer operand1, Integer operand2) throws Exception { int op1 = operand1.intvalue(); int op2 = operand2.intvalue(); if (operator.equals("+")) return new Integer(op1 + op2); if (operator.equals("-")) return new Integer(op1 - op2); if (operator.equals("*")) return new Integer(op1 * op2); if (operator.equals("%")) return new Integer(op1 / op2); throw new Exception("Unknown operator " + operator); // Returns true if op is +, -, *, or % static boolean isbinaryoperator(string op) { return op.equals("+") op.equals("-") op.equals("*") op.equals("%"); // Returns the value of the arithmetic expression described by expr // Throws an exception if the expression is malformed static Integer evaluate(string expr) throws Exception { StringTokenizer st=new StringTokenizer(expr,delimiters,true); Stack operators = new Stack(); // stack for the operators Stack numbers = new Stack(); // stack for the operands while (st.hasmoretokens()) { // read the tokens one by one String element = st.nexttoken(); Integer token = new Integer("*"); if (element.equals(")")) { if (!operators.empty() && operators.pop().equals("(")) { // if the parentheses block that just ended was a right operand if (operators.empty()) continue; if (isbinaryoperator((string)operators.peek())) { if (numbers.size()<2) throw new Exception("Malformed expression"); Integer num2=(integer)numbers.pop(); Integer num1=(integer)numbers.pop(); numbers.push(apply((string)operators.pop(),num1,num2)); else throw new Exception("Unmatched )"); continue; if (Character.isDigit(element.charAt(0))) { // we have a number Integer value=integer.valueof(element); // if this is the first operand, just push it if (operators.empty() operators.peek().equals("(")) numbers.push(value); else { // this is the second operand. if (isbinaryoperator((string)operators.peek())) { numbers.push(apply((string)operators.pop(),(integer)numbers.pop(),value)); else throw new Exception("Malformed expression"); continue; // if we get here, it's because the element is an operator or a ( if (delimiters.indexof(element)!=-1) operators.push(element); else throw new Exception("Illegal token "+element); if (numbers.size()!=1!operators.empty()) throw new Exception("Malformed expression"); return (Integer) numbers.pop(); Question 2. (15 points) Consider the following recurrence: T(n) = 1 if n = 1 2 * T(n - 1) + n if n > 1 a) (10 points) Obtain an explicit formula for the following recurrence using one of the techniques seen in class. In the process of doing so, you will possibly come across the summation Σ i=1 n ( i * 2 i ), which can be simplified as 2 * (1 + 2 n * (n-1) ). T(n) = 2 * T(n-1) + n

2 = 2 * (2 * T(n-2) + n-1) + n = 4 T(n-2) + 3 n 2 = 4 (2*T(n-3) + n-2) + 3 n 2 = 8 T(n-3) + 7n 2 8 = 8 ( 2* T(n-4) + n 3) + 7n 2 8 = 16 T(n-4) + 15n (after k substitutions) = 2 k T(n-k) + (2 k 1 ) n ( Σ i=1 k-1 i * 2 i ) = 2 k T(n-k) + (2 k 1 ) n 2 * (1 + 2 k-1 * (k-2) ) When k = n-1, the recursion stops, and we get T(n) = 2 n-1 T(1) + (2 n-1 1 ) n 2 * (1 + 2 n-2 * (n-3) ) = 2 n-1 + (2 n-1 1 ) n 2 * (1 + 2 n-2 * (n-3) ) = 2 n+1 n - 2 Informal check: Based on the recursive formula, we get: T(1) = 1 T(2) = 2* T(1) + 2 = 4 T(3) = 2* T(2) + 3 = 11 T(4) = 2 * T(3) + 4 = 26 T(5) = 2* T(4) + 5 = 57 Based on our explicit formula, we get: T(1) = (2 0 1 ) 1 2 * ( * (1-3) ) = * (1 1) = 1 T(2) = 2 + (2 1) * 2 2 (1 + 1*-1) = 4 T(3) = 4 + (4-1)*3 2 (1 + 2* 0) = 11 T(4) = 8 + (8-1)*4 2 (1 + 4*1) = 26 T(5) = 16 + (16-1)*5 2 * (1 + 8*2) = 57 So everything looks good b) (5 points) Prove your result using induction. Let P(n) be the prosition: T(n) = 2 n+1 n 2. We show that P(n) holds for any value of n >= 1. Base case: If n=1, T(1) = 1 (by definition), and 2 n+1 n 2 = = 1 Induction step: Assume that P(k) is true for some value k>=1, i.e. T(k) = 2 k+1 k 2. We need to show that this implies that P(k+1) is true, i.e. T(k+1) = 2 k+2 - (k+1) 2. T(k+1) = 2 T(k) + k + 1 (by definition of T() ). = 2 (2 k+1 k 2) + k +1 = 2 k+2 k - 3 = 2 k+2 (k+1) - 2 Thus, P(k) implies P(k+1), so, by the principle of induction, P(n) will be true for any value of n >= 1. Question 3. (20 points) You are a hiker planning a long trip of n days in the mountains of the Atacama desert (in Chile). Your trail goes in a straight line from west to east, but its altitude varies because of the mountains it crosses. Since it is a very hot place, you will walk exactly one

3 (horizontal) mile per day. Your significant other agrees to join you for the trip but, since he/she is very romantic, he/she wants to know how many sunsets you will witness. You have a map that indicates the altitude of every campsite along the way, stored in an array altitude[0...n-1]. When at campsite i, you will be able to see the sunset only if, looking west, there are no points with an altitude higher than you within the previous n/5 miles, i.e. altitude[i] altitude[i-k] for all k = 1...n/5. The trail starts at the Pacific Ocean, so the altitudes west of campsite 0 are all zero. Assume that during any given day, the altitude either increases monotonically, decreases monotonically, or does not change at all. Since it has not rained in the Atacama desert for the last 100 years, you can safely assume it will never be cloudy. See Figure below for an example when n=12. a) (5 points) Write (in pseudocode) a simple nested-for-loops algorithm to compute the number of sunsets you will witness. The running time of your algorithm should be O(n 2 ). Algorithm CountSunsets(altitudes, n) Input: An array altitudes[0...n-1] Output: The number of sunsets witnessed. nbsunsets = 0 for i = 0 to n-1 do hassunset = true; for k = 1 to n/5 do if (i-k>=0 and altitude[i-k] > alttitude[i]) hassunset = false; if (hassunset) nbsunsets++; return nbsunsets; b) (10 points) Quite surprisingly, it is possible to calculate the number of sunsets in time O(n). This is achieved by using a Stack to keep track of the positions of the campsites that have a chance of blocking sunsets for upcoming days. For example, from campsite 7 in the figure below, only position 6 has a chance of blocking the sunset in the future, as all campsites before 6 have lower altitude than it. From campsite 14, only sites 13 and 8 have a chance of blocking sunsets. By updating the content of the stack as you progress through the campsites, you can significantly reduce the number of campsites whose altitude is compared to the current one. Your algorithm will probably involve nested loops (the outer loop being over all campsites, the inner loop being other over the content of the stack), but think about carefully and you will see that the running time will nonetheless be O(n). 1) Here is the idea of the algorithm. We scan the altitude array from left to right. We keep a stack to remember all campsites that have the potential of interrupting a sunset up to the current campsite. That is, after having processed campsite i, what is on the stack are the campsites j i such that for all k between j+1 and i, altitude[k] < altitude[j]. Algorithm CountSunsets(altitudes, n) Input: An array altitudes[0...n] Output: The number of sunsets witnessed. Stack S = new Stack() Sunset = 0

4 for i = 0 to n do while (!S.empty() and altitudes[s.top()]<altitudes[i]) do S.pop() if (S.empty() or i S.top() >= n/5 ) then sunset = sunset +1 S.push(i) return sunset b) (5 points) Argue (in English, no formal proofs) why your algorithm runs in time O(n). Why does it run in time O(n)? After all, there are two nested loops and each of them can go for up to n iterations, so why is it not O(n 2 )? Notice that the only thing the while loop does is popping things from the stack. It never pushes things on the stack. Since each of the n elements of the stack are going to be pushed exactly once and removed at most once, the total running time for pushing and popping will be O(n). In other words, it could be that for some value of i, the while loop may take a lot of time to execute, popping a lot of things from the stack. However, this means that in later iterations of the for loop, the stack will be much smaller and the while loop will thus take less time. In total, over all iterations of the for loop, the while loop cannot be executed more than n times because that would mean that more than n elements were popped. Question 4 (10 points) Consider the following magic trick. You have a deck of n cards, labeled 1,2,...,n (but not necessarily in that order). You then repeat the following process until no cards are left: (i) Show to the public the card on the top of the deck, and remove it from the deck, and (ii) Take the next card from the top of the deck and place it at the bottom of the deck, without showing it. Your goal is to have previously ordered the cards in the deck so that the cards shown to the public are in increasing order: 1, 2,..., n. For example, if n=5, then starting from the arrangement 1,5,2,4,3 would work: 1,5,2,4,3 -> 2,4,3,5 -> 3,5,4 -> 4,5 -> 5 Question: Write an algorithm that prints the appropriate initial ordering for any given number n of cards. Algorithm ordercards(n) Input: An integer n Output: Prints the correct card ordering. Here s the simplest solution, which proceed backward to reverse the series of operations required to produce the right output of cards: LinkedList deck <- new LinkedList For i = n downto 1 do { Deck.rotateRight() // brings to the front the card at the back of the deck Deck.addFirst(i) Here, the rotateright method simply removes the last element from the list and places it in front on the list. Question 5. (10 points)

5 We have seen it class the precise meaning of the notation f(n) O(g(n)), essentially meaning that f(n) grows at most as fast as a constant times g(n). A similar notation can be used to say that f(n) grows at least as fast a constant times g(n), using the Omega notation: f(n) Ω( g(n) ) if and only if g(n) O(f(n)). Finally, we can express the fact that f(n) grows exactly as fast as a constant times g(n) using the Theta notation: f(n) Θ( g(n) ) if and only if f(n) O(g(n)) and f(n) Ω( g(n) ). Question: Prove that log( n! ) Θ( n log(n) ) First, we show that log(n!) O(n log n). For this, we need to find c and N such that for all n N, log(n!) c n log(n). This is the easy part, as c=1 and N = 1 will work: log(n!) = log ( n * (n-1) * (n-2)...* 2 * 1 ) = log(n) + log (n-1) + log(n-2) log(2) + log(1) log(n) + log(n) + log(n) log(n) + log(n) = n log(n) = c n log(n) Thus, log(n!) O(n log n). Now, to prove that n log n O(log(n!)), we need to find c and N such that for all n N, n log n c log(n!). This time, it will be easier to start with the right side of the inequality. Let s not pick c and N yet and see what we d need. log(n!) = log(n) + log (n-1) + log(n-2) log(n/2 +1) + log(n/2) log(2) +log(1) n/2 log(n/2) + n/2 log(1) = n/2 log(n/2) = n/2 (log(n) 1) n/2 (log(n) ½ log(n)) if n 4 = 1/4 n log(n) Thus, for N=4, c = 4, we get that n log(n) 4 n log(n) for all n N