For any Assignment related queries, Call us at : -  

+1 678 648 4277

You can mail us at : - [email protected] or
reach us at : - www.computernetworkassignmenthelp.com/

Problems and Solutions

Problem 1. True or False.

Circle T or F for each of the following statements to indicate whether the

statement is true or false and briefly explain why.

(a) T F With all equal-sized intervals, a greedy algorithm based on the

earliest start time will always select the maximum number of compatible
intervals.

Solution: True. The algorithm is equivalent to the earliest finish time

algorithm.

(b) T F The problem of weighted interval scheduling can be solved in O(n

log n) time using dynamic programming.

Solution: True. The algorithm was covered in recitation.

(c) T F If we divide an array into groups of 3, find the median of each group,
recursively find the median of those medians, partition, and recurse, then we
can obtain a linear-time median-finding algorithm.

Solution: False. T(n) = T(n/3) + T(2n/3) + O(n) does not solve to T(n) =
O(n). The array has to be broken up into groups of at least 5 to obtain a
lineartime algorithm.
Solution: False. The time complexity would satisfy the recurrence T(n) =
2T(n/2) + Θ(n2), which solves to Θ(n2) by the Master Theorem.

(e) T F Van Emde Boas sort (where we insert all numbers, find the min, and
then repeatedly call SUCCESSOR) can be used to sort n = lg u numbers in
O(lg u· lg lg lg u) time.

Solution: False. Inserting into the tree and then finding all the successors
will take n lg lg(u) time, which in terms of u is lg(u) · lg lg(u).

(f) T F Van Emde Boas on n integers between 0 and u − 1 supports

successor queries in O(lg lg u) worst-case time using O(n) space.

Solution: False. We use Θ(u) space or do randomization.

(g) T F In the potential method for amortized analysis, the potential energy
should never go negative.

Solution: True.

(h) T F The quicksort algorithm that uses linear-time median finding to run
in worst-case O(n log n) time requires Θ(n) auxiliary space.

Solution: False. It can be implemented with O(log n) auxiliary space.

(i) T F Searching in a skip list takes Θ(log n) time with high probability,
but could take Ω(2n) time with nonzero probability.

Solution: True. A skip list could be of any height with nonzero probability,
depending on its random choices.
Alternative solution: False. We can limit the height of the skip list to O(n)
or O(lg n) to get O(n) worse-case cost.
Common mistake 1: We go through each element at least once. (Wrong
because we also need to “climb up” the skip lists.

Common mistake 2: The worst case is when none of the elements is

promoted, or all of the elements are promoted to the same level, in which
cases skip lists become a linked list.

(j) T F The following collection H = {h1, h2, h3} of hash functions is

universal, where each hash function maps the universe U = {A, B, C, D} of
keys into the range {0, 1, 2} according to the following table:

Solution: False. A and C collide with probability 2/3.

Problem 2. Fast Fourier Transform (FFT). (1 part)

Ben Bitdiddle is trying to multiply two polynomials using the FFT. In his
trivial example, Ben sets a = (0, 1) and b = (0, 1), both representing 0 + x,
and calculates:

So c represents 1 + 0 · x, which is clearly wrong. Point out Ben’s mistake in

one sentence; no calculation needed. (Ben swears he has calculated FFT F
and inverse FFT F −1 correctly.)
Solution: The resulting polynomial is of degree 2, so Ben need to pad a and
b with zeroes. (Or Ben need at least 3 samples to do FFT).
Here is the correct calculaton (not required in the solution). Let a = b = (0,
1, 0, 0); then,

which represents x2. It is also OK to set a = b = (0, 1, 0).

Common mistake 1: A ∗ B should be convolution.

Common mistake 2: Ben should reverse b.

Both mistakes confuse the relation between convolution, polynomial

multiplication and FFT calculation. If one computes convolution directly
(without FFT), one needs to reverse the second vector. FFT provides a
faster way to compute convolution and polynomial multiplication (these
two are the same thing). Using the FFT, one should perform FFT on the
two original vectors (no reversal). Then, after the FFT, one only needs to
do element-wise multiplication (as opposed to convolution), which Ben
Problem
performed3.correctly.
Yellow Brick Road. (1 part)

Prof. Gale is developing a new Facebook app called “Yellow Brick Road”
for maintaining a user’s timeline, here represented as a time-ordered list
e0, e1, . . . , en−1 of n (unchanging) events. (In Facebook, events can
never be deleted, and for the purposes of this problem, don’t worry about
insertions either.) The app allows the user to mark an event ei as yellow
(important) or grey (unimportant); initially all events are grey. The app
also allows the user to jump to the next yellow event that comes after the
event ei currently on the screen (which may be yellow or grey). More
formally, you must support the following operations:

1. MARK-YELLOW(i): Mark ei yellow.

2. MARK-GREY(i): Mark ei grey.
3. NEXT-YELLOW(i): Find the smallest j > i such that ej is yellow.
Give the fastest data structure you can for this problem, measured according
to worst-case time. The faster your data structure, the better.

Hint: Use a data structure you have seen in either 6.006 or 6.046 as a
building block.

Solution: Initialization takes O(n lg(lg(n))) time to insert all the yellow
elements into a VEB tree, V.

More importantly, each operation takes O(lg lg(n)) time. When a user asks
to MARK-YELLOW(i), then call V.insert(i) which takes O(lg lg(n)) time.
When a user asks to MARK-GREY(i), then call V.delete(i) which takes
O(lg lg(n)) time. When a user asks to NEXT-YELLOW(i), then call
V.successor(i) which takes O(lg lg(n)) time.

Another slower solution used an AVL tree in place of a vEB for an O(lg(n))
runtime for the operations.

Common mistake 1: Claiming operations took O(lg lg(u)). The universe

size is exactly n, and the term u was undefined.

Common mistake 2: Inserting both yellow and grey elements into the same
data structure without an augmentation to keep track of whether any yellow
elements mistake
Common existed within
3: Usechildren.
a skip listNextYellow could
to keep track take
of all O(n) elements.
yellow in the worst
case. operations would take O(lg(n)) with high probability, but O(n) worst
Some
case

Common mistake 4: Using a skip list capped at 2 levels, doubly linked list,
or hash table. Some operations would take O(n) worst case.
Problem 4. Amortized Analysis. (1 part)

Design a data structure to maintain a set S of n distinct integers that

supports the following two operations:

1. INSERT(x, S): insert integer x into S.

2. REMOVE-BOTTOM-HALF(S): remove the smallest n 2 integers from

S.

Describe your algorithm and give the worse-case time complexity of the
two operations. Then carry out an amortized analysis to make INSERT(x,
S) run in amortized O(1) time, and REMOVEBOTTOM-HALF(S) run in
Solution:
amortized 0 time.
Use a singly linked list to store those integers. To implement INSERT(x, S),
we append the new integer to the end of the linked list. This takes Θ(1)
time. To implement REMOVE-BOTTOMHALF(S), we use the median
finding algorithm taught in class to find the median number, and then go
through the list again to delete all the numbers smaller or equal than the
SupposeThis
median. the runtime of REMOVE-BOTTOM-HALF(S)
takes Θ(n) time. is bounded by cn for
some constant c. For amortized analysis, use Φ = 2cn as our potential
function. Therefore, the amortized cost of an insertion is 1 + ΔΦ = 1 + 2c =
Θ(1). The amortized cost of REMOVE-BOTTOM-HALF(S) is cn + ΔΦ = cn
+ (−2c × n5.2Verifying
Problem ) = 0. Polynomial Multiplication. (4 parts)

This problem will explore how to check the product of two polynomials.
Specifically, we are given three polynomials:
 We want to check whether p(x)· q(x) = r(x) (for all values x).
Via FFT, we could simply compute p(x)· q(x) and check in O(n log n) time.
Instead, we aim to achieve O(n) time via randomization.

(a) Describe an O(n)-time randomized algorithm for testing whether p(x) ·

q(x) = r(x) that satisfies the following properties:

1. If the two sides are equal, the algorithm outputs YES.

2. If the two sides are unequal, the algorithm outputs NO with probability at
least 1 2 . Pick a value a ∈ [1, 4n], and check whether p(a)q(a) = r(a). The
Solution:
algorithm outputs YES if the two sides are equal, and NO otherwise. It takes
O(n) time to evaluate the three polynomials of degree O(n). Thus the overall
running time of the algorithm is O(n).

(b) Prove that your algorithm satisfies Property 1.

Solution: If p(x) · q(x) = r(x), then both sides will evaluate to the same thing
for any input.
(c) Prove that your algorithm satisfies Property 2.
Hint: Recall the Fundamental Theorem of Algebra: A degree-d polynomial
has (at most) d roots.

Solution: s(x) = r(x) − p(x) · q(x) is a degree-2n polynomial, and thus has at
most 2n roots. Then 2n 1 Pr{s(a) = 0} ≤ = 4n 2 ince a was picked from a set
of size
(d) 4n. a randomized algorithm to check whether p(x)· q(x) = r(x) that is
Design
correct with probability at least 1 − ε. Analyze your algorithm in terms of n
and 1/ε.

Solution: We run part a m times, and output YES if and only if all answers
output YES. In other words, we amplify the probability of success via
repetition. m Our test works with probability ≥ 1 − 2 1 . Thus we need 1 m
Problem 6. Dynamic Programming. (2 parts)

Prof. Child is cooking from her garden, which is arranged in grid with n rows
and m columns. Each cell (i, j) (1 ≤ i ≤ n, 1 ≤ j ≤ m) has an ingredient
growing in it, with tastiness given by a positive value Ti,j . Prof. Child
doesn’t like cooking “by the book”. To prepare dinner, she will stand at a cell
(i, j) and pick one ingredient from each quadrant relative to that cell. The
tastiness of her dish is the product of the tastiness of the four ingredients she
chooses. Help Prof. Child find an O(nm) dynamic programming algorithm to
maximize the tastiness of her dish. Here the four quadrants relative to a cell
(i, j) are defined as follows:

Because Prof. Child needs all four quadrants to be non-empty, she can only
stand on cells (i, j) where 1 < i < n and 1 < j < m.
(a) Define TLi,j to be maximum tastiness value in the top-left quadrant of
cell (i, j): TLi,j = max{Ta,b | 1 ≤ a ≤ i, 1 ≤ b ≤ j}. Find a dynamic
programming algorithm to compute TLi,j , for all 1 < i < n and 1 < j < m, in
O(nm) time.

Solution: When trying to calculate TLi,j , we see that the maximum can be
at cell (i, j). If not, it must lie either in the rectangle from (1, 1) to (i, j − 1),
or the rectangle from (1, 1) to (i − 1, j), or both. These three overlapping
cases cover our required rectangle. We have then,
TLi,j = max{Ti,j , TLi−1,j , TLi,j−1}
For the base cases, we can just set TL0,j = TLi,0 = 0 for all valid values of i
and j. We can compute the DP value for each state in O(1) time. There are
nm states, so our algorithm is O(nm).
 (b) Use the idea in part (a) to obtain an O(nm) algorithm to find
the tastiest dish.
Solution: In part (a) we calculated range maximum for the top-left
quadrant. We can similarly define range maximums for the other quadrants.
Let BLi,j = max{Ta,b | i ≤ a ≤ n, 1 ≤ b ≤ j}, TRi,j = max{Ta,b | 1 ≤ a ≤ i, j ≤
b ≤ m}, and BRi,j = max{Ta,b | i ≤ a ≤ n, j ≤ b ≤ m}. Each of these can be
computed in O(nm) time similar to TL.
To calculate the tastiest dish Prof. Child can cook when she stands at cell (i, j)
(1 < i < n and 1 < j < m), we now just need to compute the product
TLi−1,j−1BLi+1,j−1TRi−1,j+1BRi+1,j+1 and pick the maximum product.
This can be done in O(nm) time.
Problem 7. Median of two sorted arrays. (3 parts)

Finding the median of a sorted array is easy: return the middle element. But
what if you are given two sorted arrays A and B, of size m and n
respectively, and you want to find the median of all the numbers in A and B?
You may assume that A and B are disjoint.
(a) Give a na¨ıve algorithm running in Θ(m + n) time.

Solution: Merge the two sorted arrays (which takes O(m + n) time) and find
the median using linear-time selection.
(b) If m = n, give an algorithm that runs in Θ(lg n) time.
Solution: Pick the median m1 for A and median m2 for B. If m1 = m2,
return m1. If m1 > m2, remove the second half of A and the first half of
B. Then we get two subarrays with size n/2. Repeat until both arrays are
smaller than a constant. m1 < m2 is symmetric.
(c) Give an algorithm that runs in O(lg(min{m, n})) time, for any m and n.
Don’t spend too much time on this question!
Solution: Without loss of generality, assume |A| = m > n = |B|. We can
safely remove elements A[0 : m− 2 n] and A[ m+ 2 n : m − 1] because
none of these elements can be the median of A + B. After this process, we
get two arrays of size approximately n. Then we can run part (b). The
complexity is Θ(lg(min(m, n)))