Solution to CS 515 Assignment 2 - Classes

Solution to CS 515 Assignment 2
(With inputs from Fawaz Alazemi and MingChieh Chang)
Ex. 2 To find n, solve f(n) = 60 × 60 × 10 10
a) f(n) = n 2 =⇒ n = 6 × 10 6
b) f(n) = n 3 =⇒ n ≈ 33019
c) f(n) = 100n 2 =⇒ n = 6 × 10 5
d) f(n) = nlog 10 (n)/nlog 2 (n) =⇒ n ≈ 2.88 × 10 12 /n ≈ 9 × 10 11
e) f(n) = 2 n =⇒ n ≈ 45
f) f(n) = 2 2n =⇒ n ≈ 5
Ex. 4 The functions can be compared by taking the log 2 of each.
g 1 (n) = 2√
log(n)
=⇒ log(g 1 (n)) = √ log(n)
g 2 (n) = 2 n =⇒ log(g 2 (n)) = n
g 3 (n) = n(log(n)) 3 =⇒ log(g 3 (n)) = 3log(log(n)) + log(n)
g 4 (n) = n 4 3 =⇒ log(g 4 (n)) = 4 3 log(n)
g 5 (n) = n log(n) =⇒ log(g 5 (n)) = log(n)log(n)
g 6 (n) = 2 2n =⇒ log(g 6 (n)) = 2 n
g 7 (n) = 2 n2 =⇒ log(g 7 (n)) = n 2
Comparing the above, the following relationships are easy to deduce:
g 1 < g 3 ?g 4 < g 5 < g 2 < g 7 < g 6
For g 3 and g 4 :
log(g 3 (n)) = 3log(log(n)) + log(n) and re-arranging R.H.S of log(g 4 (n)),
log(g 4 (n)) = 1 3log(n) + log(n)
∴ g 3 (n) < g 4 (n)
Ex. 5
a) False.
If f(n) = c > 1 and g(n) = 1, f(n) = O(g(n)).
But, log(f(n)) = log(c) > log(g(n)) = log(1) = 0 when c > 1.
=⇒ log(f(n)) ≠ O(log(g(n))).
b) False.
Let c > 1, f(n) = c × n and g(n) = n. Then, f(n) = O(g(n)).
But, 2 (f(n)) = 2 c×n = (2 c ) n > 2 (g(n)) = 2 n when c > 1.
=⇒ 2 (f(n)) ≠ O(2 (g(n)) ).
c) True.
Since f(n) and g(n) describe run-times, they are considered positive. f(x) = x 2 is
uniformly increasing for x > 0. So, for n > 0, f(n) = O(g(n)).
=⇒ f(n) 2 = O(g(n) 2 )
Ex. 6 a) Max # of operations inside the inner for loop (when i = 1)
= 1 + 2 + 3 + · · · + (n − 2) + (n − 1)
= n(n−1)
2
=⇒ For every iteration of the outer for loop, there are O(n 2 ) operations inside the
inner for loop
Since the outer loop runs n times, the algorithm is O(n 3 )
b) Consider # of operations till i = n 4 .
When i = 1, # of addition operations = 1 + 2 + · · · + (n − 1).
1

When i = 2, # of addition operations = 1 + 2 + · · · + (n − 2).
· · ·
When i = n 4 , # of addition operations = 1 + 2 + · · · + 3n 4 .
T (n) > T ( n 4 ) = n 4 × ( n(n−1)
2
+ (n−1)(n−2)
2
+ · · · + 9n2 −12n
32
) > 9n3
=⇒ The algorithm is Ω(n 3 ) and n 3 is a tight bound.
c) There are many ways of doing this, including the following:
for i = 2 to n do
A[i] ← A[i − 1] + A[i]
for i = 1 to n do
for j = i + 1 to n do
if i > 1 then
B[i, j] ← A[j] − A[i − 1]
else
B[i, j] ← A[j]
The first for loop takes O(n) time. For each iteration of the inner for loop, only a
single operation is performed. For a given value of i, this loop runs for a maximum
of n − 1 times (1st iteration). The outer for loop runs n times. =⇒ The nested for
loops take O(n 2 ) time.
Running time of algorithm = O(n 2 )
Ex. 7 Let the # of verses in the song be v.
Given: # of words in each line is bounded by c and the total # of words is n.
∴ c + 2c + 3c + · · · + v · c = n
c(1 + 2 + 3 + · · · + v) = n
i.e. v 2 + v − 2n c = 0
√ c+8n−
√ c
2 √ c
v = ±
Since the # of unique lines is the same as the # of verses and the # of words required to
encode instructions for repetition can be shown to be negligible, the length of the script is
O( √ n)
128 .
Ex. 8
a) Let the rungs be numbered 1, 2, 3, · · · , n. If we have 2 jars, the strategy is to divide
n rungs into groups of = ⌈√ n⌉ rungs each and drop the first jar from rungs
n
⌊ √ n⌋
numbered ⌊ √ n⌋, 2⌊ √ n⌋, 3⌊ √ n⌋, · · · , n − (n mod ⌊ √ n⌋) until the jar breaks.
If the jar breaks on rung i⌊ √ n⌋, drop the other jar from rung (i − 1)⌊ √ n⌋ + 1 to
i⌊ √ n⌋ − 1 until that jar breaks.
Max # of drops required in step 1 = max # of groups = √ n.
Max # of drops required in step 2 = max # of rungs in any group = √ n.
Hence, total number of drops required is O( √ n), which is clearly sub-linear.
b) Similar to (a), when there are k > 2 jars, the strategy is to divide n rungs
into groups of = ⌈ k√ n⌉ rungs and drop the first jar from rungs numbered
n
⌊ k√ n⌋
⌊ k√ n⌋, 2⌊ k√ n⌋, 3⌊ k√ n⌋, · · · , n − (n mod ⌊ k√ n⌋) until it breaks.
If the jar breaks on rung i⌊ k√ n⌋, recursively divide the number of rungs in the interval
((i − 1)⌊ k√ n⌋, i⌊ k√ n⌋) by their (k − 1) th root to get groups within that interval. Do
this until only one jar is left. Then, drop that jar from each rung in the last group
starting with the lowest.
In each step, the max # of drops required = max possible # of groups in any interval =
k√ n.
Max # of drops required when only 1 jar remains = max possible rungs in any group
= k√ n.
Hence, total number of drops required is O( k√ n).
Also, lim n→∞
n k
1
n k−1
1
= 0
2