CS 161 Summer 2009

Homework #2 Sample Solutions

Regrade Policy: If you believe an error has been made in the grading of your homework,
you may resubmit it for a regrade. If the error consists of more than an error in addition of
points, please include with your homework a detailed explanation of which problems you
think you deserve more points on and why. We reserve the right to regrade your entire
homework, so your final grade may either increase or decrease.

Problem 1 [24 points]

Remarks: (1) You need to specify the constant ² and c in formal proof; (2) To apply
case 3 of Master Theorem, you need to check regularity condition first.

(a) (3 points) T (n) = 3T (n/2) + n log n

Answer: T (n) = Θ(nlog2 3 ).
We will apply case 1 of the Master Theorem. Since f (n) = n log n and nlogb a =
nlog2 3 ≈ n1.58 . We can pick ² = 0.1 to satisfy the conditions of the theorem. Therefore
T (n) = Θ(nlog2 3 ).

(b) (3 points) T (n) = 5T (n/5) + n/ log n

Answer: T (n) = Θ(n log log n).
We have a = 5, b = 5, f (n) = n/ log n. So nlogb a = n. None of the Master Theorem
cases may be applied here, since f (n) is neither polynomially bigger or smaller than
n, and is not equal to Θ(n logk n) for any k ≥ 0. Therefore, we will solve this problem
by algebraic substitution.

T (n) = 5T (n/5) + n/ log n

= 5(5T (n/25) + (n/5)/ log(n/5)) + n/ log n
= 25T (n/25) + n/ log(n/5) + n/ log n
...
i−1
X
= 5i T (n/5i ) + (n/ log(n/5j ))
j=0

1
2

When i = log5 n, then first term reduces to 5log5 n T (1), so we have

log5 n−1
X
T (n) = nΘ(1) + (n/ log(n/5j ))
j=0
log5 n−1
X
= Θ(n) + n (1/(log n − j log 5))
j=0
log5 n−1
X
= Θ(n) + n/ log 5 (1/(log5 n − j))
j=0
log5 n
X
= Θ(n) + n log5 2 (1/k)
k=1

This is the harmonic sum, so we have T (n) = Θ(n) + c2 n ln(log5 n) + Θ(1) =

Θ(n log log n)
√
(c) (3 points) T (n) = 4T (n/2) + n2 n
√
Answer: T (n) = Θ(n2 n).
√
We will use case 3 of the Master Theorem, Since f (n) = n2 n = n2.5 and nlogb a =
nlog2 4 = n2 . We can pick ² = 0.1 to satisfy the conditions of the theorem. Moreover
if c = 0.9 we can verify that 4(n/2)2.5 ≤ c n2.5 . Therefore the premises for case 3
√
hold and we conclude that T (n) = Θ(n2 n).
(d) (3 points) T (n) = 3T (n/3 + 5) + n/2
Answer: T (n) = Θ(n log n).
We will solve the problem by guess-and-check. By induction, T (n) is a monotonically
increasing function. Thus, for the lower bound, since T (n/3) ≤ T (n/3 + 5), using
case 2 of the Master Theorem, we have T (n) = Ω(n log n).
For the upper bound, we can show T (n) = O(n log n).
For the base cases ∀ n ≤ 30, we can choose a sufficiently large constant d1 such that
T (n) < d1 n log n.
For the inductive step, assume for all k < n, that T (n) < d1 n log n. Then for
k = n > 30, we have n/3 + 5 < n − 15, then
T (n) = 3T (n/3 + 5) + n/2
< 3T (n − 15) + n/2
< 3(3T ((n − 15)/3 + 5) + (n − 15)/2) + n/2
< 9T (n/3) + 3(n − 15)/2 + n/2
< 9d1 (n/3) log(n/3) + 2n − 45/2
< 3d1 n log(n/3) + 2n − 45/2
< 3d1 n log n
 CS161 Homework #2 Sample Solutions 3

2
The last line holds for n ≥ 1 and d1 > 3 log 3 . Thus we can proof by induction that
T (n) < cn log n for all n, where c = max{d1 , 3d1 , log2 3 }.
Therefore, T (n) = O(n log n) and T (n) = Θ(n log n).
(e) (3 points) T (n) = 2T (n/2) + n/ log n
Answer: T (n) = Θ(n log log n).
Similar to part(b).
(f) (3 points) T (n) = T (n/2) + T (n/4) + T (n/8) + n
Answer: T (n) = Θ(n).
We solve this problem by guess-and-check. The total size on each level of the recur-
rence tree is less than n, so we guess that f (n) = n will dominate.
Base case, for n0 = 1, we have T (n) = n.
Inductive step: Assume for all i < n that c1 n ≤ T (i) ≤ c2 n. Then,
c1 n/2 + c1 n/4 + c1 n/8 + kn ≤ T (n) ≤ c2 n/2 + c2 n/4 + c2 n/8 + kn
c1 n(7/8 + k/c1 ) ≤ T (n) ≤ c2 n(7/8 + k/c2 )
If c1 ≥ 8k and c2 ≤ 8k, then c1 n ≤ T (n) ≤ c2 n. So, T (n) = Θ(n).
(g) (3 points) T (n) = T (n − 1) + 1/n
Answer: T (n) = Θ(log n).
We solve this problem by algebraic substitution.
T (n) = T (n − 1) + 1/n
= T (n − 2) + 1/(n − 1) + 1/n
...
n
X
= Θ(1) + 1/i
i=1
= Θ(1) + ln n
√ √
(j) (3 points) T (n) = nT ( n) + n
Answer: T (n) = Θ(n log log n).
We solve it by algebraic substitution.
√ √
T (n) = nT ( n) + n
= n1/2 (n1/4 T (n1/4 + n1/2 )) + n
= n3/4 T (n1/4 ) + 2n
= n3/4 (n1/8 T (n1/8 + n1/4 )) + 2n
= n7/8 T (n1/8 ) + 3n
...
k k
= n1−1/2 T (n1/2 ) + kn
4

k
When n1/2 falls under 2, we have k > log log n. We then have T (n) = n1−1/ log n T (2)+
n log log n = Θ(n log log n).

Problem 2 [5 points]
Answer: a = 48.
A : T (n) = 7T (n/2) + n2 . We have a = 7, b = 2, f (n) = n2 . Apply case 1 of the Master
Theorem, we get T (n) = Θ(nlog2 7 ).
A0 : T 0 (n) = aT 0 (n/4) + n2 . We have a = a, b = 4, f (n) = n2 . If log2 7 > log4 a > 2, Apply
case 1 of the Master Theorem, we will get T 0 (n) = Θ(nlog4 a ) < Θ(nlog2 7 ) = T (n). Solving
the inequation, we get a < 49.
When log4 a ≤ 2, by case 2 and case 3 of the Master Theorem, we won’t get a faster
algorithm than A.

Problem 3 [30 points]

(a) (10 points)
Insertion-Sort: O(kn). Define an ”inversion” in A as a pair (i, j) where i < j
and A[i] > A[j]. If every element is within k slots from its proper position, then
there are at most O(kn) inversions. Thus the running time for Insertion-Sort is
O(n + I) = O(kn), where I is the number of inversions in A.
The reason is because I is exactly number of shifting operations we need in Insertion-
Sort. For the inner loop of the algorithm, each element A[i] is shifted left as many
times as li where li is number of elements j so that j < i and A[j] > A[i]. Therefore
n
X
number of shif ting operations needed = li
i=1
n
X
= |{(j, i)|(j, i) is an inversion in A, ∀j}|
i=1
= total number of inversions in A

Now consider the outer loop of the Insertion-Sort algorithm. It iterates n times
as the index traverses the array and it is independent of the number of inversions.
Therefore the total running time of Insertion-Sort is O(I + n) = O(kn).

Merge-Sort: Θ(n log n). Same Recurrence function T (n) = 2T (n/2) + Θ(n).

QuickSort:
Best-case scenario, rewrite recurrence as T (n) = T (k) + T (n − k) + Θ(n). The depth
CS161 Homework #2 Sample Solutions 5

of the recurrence tree is n/k. Thus T (n) = O(n2 /k). When k << n, it is close to
O(n2 ).
Worst-case scenario (sorted), rewrite recurrence as T (n) = T (1) + T (n − 1) + Θ(n).
Thus T (n) = O(n2 ).

(b) (5 points) O(kn). The idea of the bubble-sort algorithm is, starting from the left,
compare adjacent items and keep ”bubbling” the larger one to the right until all
items reach their proper positions.
From 3(a), we know there are at most O(kn) inversions. After each swap operation
in line 6, the number of inversion will decrease by one. Thus line 6 will be executed
at most O(kn) times, which is the bottle-neck of the running time.

(c) (10 points) For the solution to this problem, we are going to use a heap. We assume
that we have a heap with the following subroutines:

• Make-Heap() returns a new empty heap.

• Insert(H, key, value) inserts the key/value pair into the heap.
• Extract-Min(H) removes the key/value pair with the smallest key from the
heap, returning the value.

We consider A as a set of sorted lists. In particular, notice that A[i] < A[i + 2k + 1],
for all i ≤ n − 2k − 1. That’s because the element at slot i can at most move forwards
during sorting to slot i + k and the element at slot i + 2k + 1 can at most move
backwards during sorting to slot i + k + 1. For simplicity, assume n is divided by 2k.
We divide the array A into 2k lists defined as follows:

A1 = [A[1], A[2k + 1], A[4k + 1], . . . , A[n − (2k − 1)]]

A2 = [A[2], A[2k + 2], A[4k + 2], . . . , A[n − (2k − 2)]]
...
A2k = [A[2k], A[4k], A[6k], . . . , A[n]]

Each of these lists is sorted, and of size ≤ n. We can sort these lists in O(n log k)
time using the Sort-K-Sorted algorithm below.
6

Algorithm 1 Sort-K-Sorted(A, n, k)
1: H = Make-Heap()
2: for i = 1 to 2k do
3: Insert(H, A[i], i)
4: end for
5: for i = 1 to n do
6: j=Extract-Min(H)
7: B[i] = A[j]
8: if j + 2k ≤ n then
9: Insert(H, A[j + 2k], j)
10: end if
11: end for
12: return B

Running time analysis: Since there are never more than 2k element in the heap, Each
Extract-Min and Insert operation requires O(log k) time. The second loop is is
repeated n times, resulting in an O(n log k) running time.

(d) (5 points) The key invariant is to show that after every iteration of the loop, the heap
contains the smallest element in every list. A formal induction proof is required here.

Alternative Solution: Recall we already know how to merge two sorted lists that con-
tain n elements in O(n) time. It is possible, then to merge the lists in a tournament. For
example, for 2k = 8, where A + B means to merge lists A and B:
Round 1: (A1 + A2 ), (A3 + A4 ), (A5 + A6 ), (A7 + A8 )
Round 2: (A1 + A2 + A3 + A4 ), (A5 + A6 + A7 + A8 )
Round 3: (A1 + A2 + A3 + A4 + A5 + A6 + A7 + A8 )
Notice that there are log k merge steps, each of which merges n elements and hence has a
cost of O(n). This leads to the total running time of O(n log k).

Problem 4 [15 points]

(a) (5 points) Merge-Sort is the most amenable one because you can give a machine
a part of the array in any order. QuickSort and Insertion-Sort are bad because
one iteration depends on the state of the array based on previous iterations, which is
complicated to communicate between machines.

(b) (5 points) Split the array into m = 2i subarrays. Call Merge-Sort on each subarray
on separate machine. Once machines start to returning answers, use free machines
to merge subarrys that are adjacent to each other.
CS161 Homework #2 Sample Solutions 7

(c) (5 points) Running time: O((n/m) log(n/m) + n).

Since we are splitting the array into m = 2i parts, each call of Merge-Sort on a
subarray of size n/m will take O((n/m) log(n/m)).Then we need to merge m sorted
array into a big one, which will take linear time O(n).
Thus the total time is O((n/m) log(n/m) + n).

Alternative Solution: At the Merge step, we can use m/2 machines to merge all pairs
of sorted subarrays, then m/4 machines for the next merge step, etc. This will give the
same Big-O running time.

Problem 5 [8 points]
Insertion-Sort: Stable. We can prove it using the following loop invariant: At the start of
each interaction of the for loop of lines 1-8 (page 17 of CLRS), if A[a] = A[b], a < b ≤ j − 1
and distinct, then A[a] appeared before A[b] in teh initial array. Proof by induction is
omitted here.

Merge-Sort: Stable. We can prove it by induction on the fact that Merge-Sort (page
29 and 32 on CLRS) is stable.
Base case: When we call Merge-Sort with indices p and r such that p 6< r (therefore
p == r), we return the same array. So calling Merge-Sort on an array of size one returns
the same array, which is stable.
Induction: We assume that calling Merge-Sort on an array of size less than n returns a
stably sorted array. We then show that if we call Merge-Sort on an array of size n, we
also return a stably sorted array. Each call of Merge-Sort contains two calls to Merge-
Sort on half arrays, and in addition, merges these two subarrays and returns. Since we
assume that the calls to Merge-Sort on smaller arrys return stably sorted arrays, we only
need to show that the Merge step on two stably sorted arrays returns a stable array. if
A[i] = A[j], i < j in the initial array, we need f (i) < f (j) in the new array, where f is the
function which gives the new positions in the sorted array. If i and j are in the same half
of the recursive Merge-Sort call, then by assumption, it hold. If i and j are in different
subarrays, then we know that i is in the left subarray and j is in the right subarray since
i < j. In the Merge step, we take the elements from the left subarray while it is less than
or equal to the right subarray element (line 13). Therefore, we will take element i before
taking element j and f (i) < f (j), the claim we are trying to prove.

Bubble-Sort: Stable. Formal proof by induction is omitted here. The key point is
that equal value elements are not swapped (line 5 in the pseudocode in Problem 3(b)).

QuickSort: NOT stable. To make it stable, we can add a new field to each array el-
ement, which indicates the index of that element in the original array. Then, when we
8

sort, we can sort on the condition (line 4 on page 146 of CLRS) A[j] > x OR A[j] == x
AND index(A[j]) < index(x). At the end of the sort, we are guaranteed to have all
the elements in sorted order, and for any i < j, such that A[i] equals A[j], we will have
index(A[j]) < index(A[i]) so the sort will be stable.

Extra Credit [5 points]

We will give a proof using the decision-tree technique.
We already know that sorting the array requires Ω(n log n) comparisons. If k > n/2, then
n log n = Ω(n log k), and the proof is complete. For the remainder of this proof, assume
that k ≤ n/2.
Our goal is to provide a lower-bound on the number of leaves in a decision tree for an
algorithm that sorts an array in which every element is within k slots of its proper position.
We therefore provide a lower bound on the number of possible permutations that satisfy
this condition.
First, break the array of size n into bn/kc blocks, each of size k, and the remainder of size
n (mod k). For each block, there exist k! permutations, resulting in at least (k!)bn/kc total
permutations of the entire array. None of these permutations move an element more than
k slots.
Notice that this undercounts the total number of permutations, since no element moves
from one k-element block to another, and we ignore permutations of elements in the re-
mainder block.
We therefore conclude that the decision tree has at least (k!)bn/kc leaves. Since the decision
tree is a binary tree, we can then conclude that the height of the decision tree is

≥ log((k!)bn/kc )
≥ bn/kc log(k!)
≥ bn/kcc1 k log k
≥ c1 (n − k) log k
≥ c1 n log k/2
= Ω(n log k)

The last step follows because of our assumption that k ≤ n/2.