Algorithms CScD-501, Exam 1: 23 February 2009 Answer Key
1. (16 points) Give either an algorithm or a programming problem that exemplifies each of the following algorithmic strategies or for which we examined use of the algorithmic strategy.
Greedy:
Change making with US currency; real-valued knapsack; Huffman codes
Divide and Conquer:
Merge Sort, Quick Sort, Binary Search, MaxMin, Search for the k'th element
Backtracking:
Can be used for 0/1 knapsack, change back. Queens problem. One approach to Pascal's Travels.
Dynamic Programming:
Calculation of Fibonacci numbers, change back, binomial coefficients. Another approach to Pascal's Travels.
2.
(4 points) When using the greedy approach to the knapsack problem (to obtain the optimal value when the approach succeeds or to obtain a first estimate when it doesn't), in what order should the items be considered in terms of their values and weights?
They should be descending order by value per weight [value density] (or equivalently increasing by weight per value).
3. (10 points) Below is the recursive pseudocode for the simultaneous calculation of the maximum and minimum values in an array. For comparisons performed, identify the base cases and the recurrence as Cmp(n). You may restrict n to n = 2k for integer k > 0.
Pair MaxMin(array segment) if segment size = 1 return element as both max and min else if segment size = 2 one comparison to determine max and min return that pair
else // segment size presumably > 2 recurse for max and min of left half recurse for max and min of right half one comparison determines true max of the two candidates one comparison determines true min of the two candidates return the pair of max and min
NOTE: TWO-SIDED PAGES
Page 1
Printed 2009-May-18 07:44
CScD-501, Algorithms Winter 2009: Exam 1
Page 2
Exam 1: 19 February 2008
Base cases:
Cmp(1) = Cmp(20) = 0 Cmp(2) = Cmp(21) = 1
Recurrence: Note: This portion (6 points) was discarded and converted to extra
credit
Cmp(n>2) = Cmd ( n / 2 ) + Cmp ( n/2 ) + 2 -- for general n Cmp(2k>1) = 2 * Cmd ( 2k1) + 2 -- for the restricted range of n = 2k
4.
(30 points -- 3 each) For each of the following, gives its worst-case (Big-O) and best-case (Big ) behavior [though they may be the same]. You should not require the explicit code to answer this, but it does contain information about the variation on the algorithm being discussed, where appropriate -- as for binary search (no early exit) and quick sort (not an intelligent partition method).
a)
Binary Search:
Worst case: O( log n )
Best case:
( log n )
static int binSearch ( Comparable[] x, int n, Comparable val) { int lo = 0, hi = n-1; while (lo < hi) // algorithm without an early exit. { int mid = (lo + hi) / 2; if (val.compareTo(x[mid]) > 0) lo = mid + 1; else hi = mid; } // end while if ( val.compareTo(x[hi]) > 0 ) // Belongs at the VERY end return n; else // Where val is (or belongs) return hi; } // end binSearch()
that is, ( log n )
b) Linear Search:
Worst case: O( n )
Best case:
( 1 )
static int linSearch ( Object[] x, int n, Object val ) { int j; for ( j = 0; n > j; j++ ) if ( val.equals(x[j]) // Single statement, no braces return j; return -1; } // end linSearch()
c)
Optimized Bubble Sort:
O( n2 ) Best case:
(n)
public static void bubbleSort(Comparable[] a) { int last; // Position of the last swap for early exit for (last = a.length-1;last>0;/*no decrement*/) { int mark = 0;// retain last swap position without changing last for (int k = 0; k < last; ++k) { if (a[k].compareTo(a[k+1]) > 0) { Comparable temp = a[k+1]; a[k+1] = a[k]; a[k] = temp; mark = k; //mark top of the swap } // end if } // end for last = mark; // update last } // end for } // end bubbleSort
Printed 2009-May-18 07:44
CScD-501, Algorithms Winter 2009: Exam 1 d) Selection Sort:
Page 3
Exam 1: 19 February 2008
O(n2 )
Best case:
(n2)
public static void selSort(Comparable[] a) { for (int lim = a.length-1; lim > 0; lim--) { int mark = 0;// largest found so far Comparable temp = a[lim]; // Start of swap for (int k = 1; k <= lim; ++k)// Find max entry { if (a[k].compareTo(a[mark]) > 0) mark = k; } // end for a[lim] = a[mark]; // Finish the swap a[mark] = temp; } // end for } // end selSort
that is, ( n2)
e)
Insertion Sort:
O(n2) Best case:
(n)
public static void insSort ( Comparable[] x, int n ) { int lim, // start of unsorted region hole; // insertion point in sorted region for ( lim = 1 ; lim < n ; lim++ ) { Comparable save = x[lim]; for ( hole = lim ; hole > 0 && save.compareTo(x[hole-1]) < 0 ; hole-- ) { x[hole] = x[hole-1]; } x[hole] = save; } // end for (lim... } // end insSort()
f)
Merge Sort:
O( n log n )
Best case:
( n log n )
public static void sort(Comparable[] a) { Comparable[] aux = (Comparable[])a.clone(); mergeSort(aux, a, 0, a.length); } static void mergeSort(Comparable[] src, Comparable[] dst, int lo, int hi) { if (hi-lo > 1) // Mixed interval: lo < index < hi { int mid = (lo + hi) / 2; mergeSort(dst, src, lo, mid); // MergeSort from dst into src mergeSort(dst, src, mid, hi); // Merge sorted halves (now in src) into dst merge(src, dst, lo, hi); // Expense merge: of hi lo } }
that is, ( n log n )
g) Quick Sort:
O(n2 ) Best case: ( n log n ) Note: Assume that the method partition uses x[lo] as pivot.
public static void qSort (Comparable [] x, int n) { qSort (0, n-1, x); } // inclusive interval: lo < index < hi) static void qSort(int lo, int hi, Comparable [] x) { while (lo < hi) // while allows for removing tail recursion { int mid = partition(lo, hi, x); // Expense is O(hi-lo) qSort(lo, mid - 1, x); // Recursive part for left lo = mid + 1; // "Tail" recursion on right } // end while }
h) Towers of Hanoi:
Worst case: O( 2n ) Best case:
( 2n )
static void hanoi ( int n, int src, int dst, int tmp ) { if ( n > 0 ) { hanoi (n - 1, src, tmp, dst); // Clear all but one move (src, dst); // move the one disk hanoi (n - 1, tmp, dst, src); // move disks on top of it } } // end hanoi()
that is, (2n)
Printed 2009-May-18 07:44
CScD-501, Algorithms Winter 2009: Exam 1 i)
Page 4
Exam 1: 19 February 2008
Optimal binomial coefficient: Worst case: O( k ) Best case: ( k ) that is, (k) This one counts for two, because it is a functionality in either n, or k, or both n and k:
public static long binom(int n, int k) { long answer = 1; // C(n-k, k-k) = C(n-k, 0) for (int ni = n-k+1, ki = 1; ki <= k; ni++, ki++) answer = ( answer * ni ) / ki; return answer; } // end binom()
5.
(10 points) The function f(n) is asymptotically smaller than g(n) if and only if the following holds:
f ( n) = 0 -- lim g ( n) n
See note on back page
1
Put the following functions into order as asymptotically smallest to asymptotically largest. Just state the order; you do not have to prove the relationship.
1, n, 2n, n1.5, n2, n, n3, nn, log2(n), n2 log(n) 1, log2(n), n, n, n1.5, n, n2 log(n) 2, n3, 2n, nn
Seat-of-the-pants: log2(1024) = 10, 1024 = 32; log2(22k) = 2k, 22k = 2k , and 2k < 2k, k > 0 Formal proof:
lim log 2 (n) d [log 2 (n)] / dn 1 / ( n ln(2) ) n1 / 2 1 = = = = 1/ 2 0 1/ 2 1/ 2 - 1 n n ln(2) n ln(2) d (n ) / dn n n
6.
(5 points) Indicate whether for each of the following problems an optimal solution can be obtained using a greedy approach -- yes/no or true/false: no Making change with the smallest number of coins based on 1, 10, 25, and 50. [Consider 30] yes Making change with the smallest number of coins based on 1, 5, 10, 25, and 50. yes Real-valued knapsack to obtain always the highest value for the knapsack's capacity. no Integer-valued knapsack to obtain always the highest value for the knapsack's capacity.
no 0/1 knapsack to obtain always the highest value for the knapsack's capacity.
Printed 2009-May-18 07:44
CScD-501, Algorithms Winter 2009: Exam 1
Page 5
Exam 1: 19 February 2008
7.
(5 points) Of which of the four algorithmic strategies we discussed is the following pseudocode an example?
Pair MaxMin(array segment) if segment size = 1 return element as both max and min else if segment size = 2 one comparison to determine max and min return that pair
else // segment size presumably > 2 recurse for max and min of left half recurse for max and min of right half one comparison determin...