120 CSC Algorithms and Data Structures
Spring Semester, 2002
Review Solutions Final
1. True or False 20n3 + 10n log n + 5 2100 log (nx ) 500 log5 n + n + 10 0.5 log n is is is is is O(n log n) FALSE (1) TRUE O(log n) where x > 0 is const TRUE O(n) TRUE (n) FALSE
2. The functions are in increasing complexity order (i.e., lowest to highest): log log n, 6 log n, n n, n2 , 2log n . 3. Express as a function of the input size n the worst-case running time T (n) of the following algorithm int Me(int n, int { int tot = 0; for (int i=n; if (i==k) cout << tot++; } } return tot; } A[], int k) // 1 i>=0; i--) { //3*(n+1) { // 3 , counting the test condition i << endl; // 1 // 1
// 1
The worst case run time and complexity are: T (n) = 3 (n + 1) + 2 = (n) 4. Give the worst-case and the best-case recurrences expressing the running time of the following algorithm manipulating a BST rooted at p. int You( int *p, int a, int b) { int tot = 0; // if (p==0) return 0; // 1
1 base case T(0)=2
if ( *p > a cout << tot++; } tot += You( tot += You( return tot; }
&& *p < b) { *p << endl;
// 3 , counting the test condition // 1 // 1
Left(p), a, b); // T(left subtree) Right(p), a, b); // T(right subtree) // 1
What are the best- and the worst-case time complexities of this algorithm? The running time of the recursive procedure on a tree with n nodes can be expressed as:
T (0) = 3 T (n) = T (lef t subtree) + T (right subtree) + 5 The analysis is similar to that for the tree traversal algorithms. The number of statements executed at each call (excluding the recursive calls themselves) is constant (5 to be precise). The procedure will be called for each node (for a subtree rooted in each node) exactly once. Since there are n nodes, and for each one the work done is constant, the total runt time is 5n. Independent of the exact tree structure, all nodes are visited, i.e. the best-and worst- case complexities are the same (n). 5. Using the master method estimate the complexity of the recursive algorithms which run times are expressed by the recurrences below. We use the notation introduced in class. (a) T (n) = 21T ( 2n ) + (n2 log3 n) 3 a = 21, b = 3/2, k = 2, p = 3 21 = a > bk = (3/2)2 , thus Case 1, (nlog3/2 21 ) (b) T (n) = 9T ( n ) + (n2 ) 3 a = 9, b = 3, k = 2, p = 0 9a = bk = 32 , thus Case 2, (n2 log n) (c) T (n) = 10T ( n ) + (n4 log n) 2 a = 10, b = 2, k = 4, p = 1 10 = a < bk = 24 , thus Case 3, (n4 log n) 2
6. Fill in the following table with the asymptotic time complexities (use expected time complexities when appropriate). Be sure to indicate which time complexities are worstcase and which are expected-case. Let n be the number of elements in the ADT. Let m be the number of slots in the hash table.
BST heap hashing with chaining (1 + n/m) average (1) worst (n) worst doubly linked sorted list (n) worst (1) worst (n) worst
search (for key k) delete(k) (when given the location of k) maximum
(h) worst case, h = n (h) worst, h = n (h) worst, h = n
(n) worst (log n) worst, del root (n) worst, in min heap
7. In a directed graph, the in-degree of a vertex is the number of edges entering it. Let n be the number of vertices, and m the number of edges in the graph, and let dI (v) be the in-degree of vertex v. Given an adjacency matrix representation of a directed graph, and a specified vertex v, how would you best compute the in-degree of v? Write your algorithm in pseudo code, analyze the time complexity of your algorithm. Here you need just to count the number of 1's in the column of the adjacency matrix corresponding to v. Since there are n entries in the column, clearly the time complexity is (n). // M is the adjacency matrix, of size nxn, M[u][v]=1 if (u,v) is an edge InDegree(M, v) int deg=0; // 1 for (int u=0; u<n; u++) // n deg += M[u][v]; // 1 return deg; // 1 Let G = (V, E) be graph with n vertices and m edges. T (n, m) = n + 3 = (n) 8. An undirected graph is bipartite if its vertex set V can be partitioned into two sunsets S and T (i.e. V = S T, S T = ) so that every edge in E connects a vertex in S to a vertex in T . Describe a brute force algorithm for checking if an undirected graph is bipartite. What's the time complexity of your algorithm. 3
ANSWER: The brute force algorithm is an exhaustive search of all two-set partitions of V , i.e., for each partition of V into two subsets S and T , check if the partition satusfies the "bipartite coindition". If you find that a partition satisfies the condidtion, return TRUE, otherwise return FALSE. Given a set on n vertices, there are n ways we can partition V into two sets one of which n has exactly one element, there are C2 = n(n-1) ways to partition V into 2 subsets one 2! k of which has exactly 2 elements, . . ., there are Cn = n(n-1)...(n-k+1) ways of partitioning k! n V into two subsets such that one has exactly elements. k Here Ck is the binomial coefficient "choose k of n". Thus, the total number of ways we can partition V into two subsets is the sum of all binomial coefficients for k = 1, . . . , n/2. Since the sum of the binomial coefficients, for k = 0, . . . , n is 2n , and since they are symmetric, n n i.e. Ck = Cn-k , the sum of the first half of the coefficients (minus 1), will be on the n-1 order of (2 ), and that will be the number of the partitions that have to be checked in worst case. For each partition, in worst case we have to check all edges to see if they connect vertices in the same subset of the partition or not. Thus the worst case complexity for the whole algorithms will be (2n-1 m) exponential!!! 9. Show the hash table obtained when inserting the keys 26, 18, 19, 32, 4, and 65 into a hash table (in the given order) with collisions resolved by chaining. Let the table have 7 slots and let the hash function h be such that h(26) = 3, h(18) = 6, h(19) = 0, h(32) = 0, h(4) = 3, h(65) = 3.) You need just show the final result. Be careful to correctly show the order that would result within the chains/lists. ANSWER: X marks the null pointer table slots 0: --> 32 --> 19 2:X 3: --> 65 ---> 4 --> 3 4:X 5:X 6: --> 18 10. Give pseudo-code for a procedure Decrease-Key(i, k) that modifies the given binary heap A by decreasing the value of A[i] to k. (If A[i] k then no change should be made.) You can use (without describing ) any of the standard binary heap procedures that we've studied. You should give the most efficient implementation you can. Now analyze the asymptotic time complexity of your algorithm. Be sure to explain! ANSWER:
4
Note that if A[i] > k, we set A[i] = k, and there is a chance that k is smaller than the key values of the ancestors of i, and the heap PORD property might be violated. As far as descendents of i are concerned, things can't go wrong. Thus we have to restore the heap order by proragating the key k up the path to the root till it falls in place (similar to insert procedure). Decrease-Key(i,k) { if (i >= 1 && A[i] > k) { while (i > 1 && k < Key(Parent(i)) ) A[i] = Key(Parent(i)) // shift key of parent down, to child i = Parent(i) A[i] = k } } The complexity in worst case is the distance from i to the root, same as in insert, i.e., O(log n) in worst-case. 11. You are to implement a caller-id system which supports the operations given in b)-d) below. Pick a data structure that is best suited for the problem (i.e. the required operation will run as efficiently as possible). You should very clearly describe how the data structure is to be applied (e.g. what is used as the key, what the associated data is,...). Also be sure to give the complexity for each of the operations. (a) Describe your data structure choice first. Answer: Operations needed are the one supported by ADT dictionary, and search in particu...