For any Homework related queries, Call us at : -  

+1 678 648 4277

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

Online Algorithms Homework Help

Problem 1. Binary Tree Practice

(a) The Set Binary Tree T below is not height-balanced

but does satisfy the binary search tree property,
assuming the key of each integer item is itself.
Indicate the keys of all nodes that are not height-
balanced and compute their skew.

Solution:

The nodes containing the keys 16 and 37 are not height

balanced. Their skews are 2 and -2 respectively.
(b) Perform the following insertions and deletions, one after
another in sequence on T, by adding or removing a leaf while
maintaining the binary search tree property (a key may need to be
swapped down into a leaf). For this part, do not use rotations to
balance the tree. Draw the modified tree after each operation.

1 T.insert(2)
2 T.delete(49)
3 T.delete(35)
4 T.insert(85)
5 T.delete(84)

Solution:
insert(2)

delete(49)

Programminghomeworkhelp.com
delete(35)

insert(85)

Programminghomeworkhelp.com
delete(84) (Two solutions, swap down predecessor/successor)

(c) For each unbalanced node identified in part (a), draw the two
trees that result from rotating the node in the original tree left and
right (when possible). For each tree drawn, specify whether it is
height-balanced, i.e., all nodes satisfy the AVL property.

Programminghomeworkhelp.com
Solution:

Node containing 16 is not height-balanced.

• Rotating left at this node does not balance the tree

• Rotating right at this node does not balance the tree:

Programminghomeworkhelp.com
Node containing 37 is not height-balanced.

• Rotating left at this node is not possible

• Rotating right at this node results in a height-balanced tree!

Problem 2. Heap Practice

For each array below, draw it as a complete1 binary tree and state
whether the tree is a max-heap, a min-heap, or neither. If the tree is
neither, turn the tree into a min-heap by repeatedly swapping items
that are adjacent in the tree. Communicate your swaps by drawing a
sequence of trees, marking on each tree the pair that was swapped.

Programminghomeworkhelp.com
(a) [4, 12, 8, 21, 14, 9, 17]

Solution: Min-heap 4

(b) [701, 253, 24, 229, 17, 22]

Solution: Max-heap

Programminghomeworkhelp.com
(c) [2, 9, 13, 8, 0, 2]

Solution: Neither: three swaps suffice to transform into a min-heap

(d) [1, 3, 6, 5, 4, 9, 7]

Solution: Min-heap

Programminghomeworkhelp.com
Problem 3.

Gardening Contest Gardening company Wonder-Grow sponsors a

nation-wide gardening contest each year where they rate gardens
around the country with a positive integer2 score. A garden is
designated by a garden pair (si, ri), where si is the garden’s
assigned score and ri is the garden’s unique positive integer
registration number.

(a) To support inclusion and reduce competition, Wonder-Grow

wants to award identical trophies to the top k gardens. Given
an unsorted array A of garden pairs and a positive integer k ≤
|A|, describe an O(|A| + k log |A|)-time algorithm to return
the registration numbers of k gardens in A with highest
scores, breaking ties arbitrarily.

Solution:

Build a max-heap from array A keyed on the garden scores si,

which can be done in O(|A|) time. Then repeatedly remove the
maximum pair k times using delete max(), and return the
registration numbers of the pairs extracted (say in an array of size
k). Because a max-heap correctly removes some maximum from
the heap with each deletion in O(log |A|) time, this algorithm is
correct and runs in O(|A| + k log |A|) time.

Programminghomeworkhelp.com
(b) Wonder-Grow decides to be more objective and award a
trophy to every garden receiving a score strictly greater than a
reference score x. Given a max-heap A of garden pairs, describe an
O(nx)-time algorithm to return the registration numbers of all
gardens with score larger than x, where nx is the number of
gardens returned.

Solution:

For this problem, we cannot afford O(nx log |A|) time to

repeatedly delete the maximum from A until the deleted pair has
score less than or equal to x. However, we can exploit the max-
heap property to traverse only an O(nx) subset of the maxheap
containing the largest nx pairs. First observe that the max-heap
property implies all nx items having key larger than x form a
connected subtree of the heap containing the root (assuming any
stored score is greater than x). So recursively search node v of the
heap starting at the root. There are two cases, either:

• the score at v is ≤ x, so return an empty set since, by the max-

heap property, no pair in v’s subtree should be returned; or
• the score at v is > x, so recursively search the children of v (if
they exist) and return the score at v together with the scores
returned by the recursive calls (which is correct by induction).

Programminghomeworkhelp.com
This procedure visits at most 3nx nodes (the nodes containing the nx
items reported and possibly each such node’s two children), so this
procedure runs in O(nx) time.

Problem-4.

Solar Supply Entrepreneur Bonty Murns owns a set S of n solar

farms in the town of Fallmeadow. Each solar farm (si, ci) ∈ S is
designated by a unique positive integer address si and a farm
capacity ci: a positive integer corresponding to the maximum energy
production rate the farm can support. Many buildings in
Fallmeadow want power. A building (bj , dj ) is designated by a
unique name string bj and a demand dj : a positive integer
corresponding to the building’s energy consumption rate.

To receive power, a building in Fallmeadow must be connected to a

single solar farm under the restriction that, for any solar farm si, the
sum of demand from all the buildings connected to si may not
exceed the farm’s capacity ci. Describe a database supporting the
following operations, and for each operation, specify whether your
running time is worst-case, expected, and/or amortized.

Programminghomeworkhelp.com
 initialize(S) Initialize database with a list S = ((s0, c0), . . . ,
(sn1, cn1)) corresponding to n solar farms in
O(n) time.

power Connect a building with name bj and demand dj

on(bj,dj) to any solar farm having available capacity at
least dj in O(log n) time (or return that no such
solar farm exists).

power off(bj) Remove power from the building with name bj

in O(log n) time.
customers(si Return the names of all buildings supplied by
) the farm at address si in O(k) time, where k is
the number of building names returned.

Solution:

Our approach will be to maintain the following data structures:

• a Priority Queue P on the solar farms, storing for each solar farm
its address si, capacity ci, and its available capacity ai (initially ai =
ci), keyed on available capacity;
• a Set data structure B mapping each powered building’s name bj
to the address of the solar farm si that it is connected to and its
demand dj ; and

Programminghomeworkhelp.com
• a Set data structure F mapping the address of each solar farm si
to: (1) its own Set data structure Bi containing the buildings
associated with that farm, and (2) a pointer to the location of si in
P.

Now we support the operations:

• initialize(S): build Set data structures P and then F from S, and

initialize all other data structures above as empty. This operation
directly maintains the invariants of our database by reducing to
build for F and P. There are O(n) empty data structures and
pointers constructed, so if we implement P and F with data
structures that can build in O(n) time, this operation will also take
O(n) time.

• power on(bj, dj): assume that bj is not already connected to

power (the operation is unspecified otherwise). First, find a solor
farm to connect by deleting a solar farm si from P having largest
available capacity ci (delete max) and checking whether it’s
capacity is at least dj . There are two cases:

– dj > ci, so reinsert the solar farm back into P (relinking a pointer
from F to a location in P) and return that no solar farm can
currently support the building.
– dj ≤ ci, so subtract dj from ci and reinsert it back into P (relinking
a pointer). Then, add bj to B mapping to si, and then find the Bi in F
associated with si and add bj to Bi.

Programminghomeworkhelp.com
This operation directly maintains the invariants of our database
and takes time asymptotically upperbounded by the sum of: one
delete max and one insert operation on P, an insert operation on
B, a find on F, an insertion into Bi, and constant additional work
(to maintain pointers and perform arithmetic).

• power off(bj): assume that bj is already connected to power (the

operation is unspecified otherwise). Lookup the si and dj
associated with bj in B, lookup Bi in F using si, and remove bj from
Bi. Lastly, go to si’s location in P and remove si from P, increase ci
by dj , and reinsert si into P. This operation directly maintains the
invariants of our database, and takes time asymptotically
upperbounded by the sum of: one lookup in B, one lookup in F,
one delete from Bi, one removal by location from P, one insertion
into P, and constant additional work.

• customers(si): lookup Bi in F using si, and return all names

stored in Bi. This operation is correct based on the invariants
maintained by the data structure (Bi contains the buildings
associated with si), and takes time asymptotically upperbounded
by the sum of: one lookup in F and one iteration through Bi.

We have shown this database can correctly support the

operations. Now we choose implementations of the data
structures in the database that will allow the operations to be
efficient. We need to be able to build B and F in O(n) time

Programminghomeworkhelp.com
with O(log n) lookups, so we must use hash tables for these,
leading to expected bounds on all operations, and amortized
bounds on power on and power off. For each Bi, we need O(log n)
lookup, insert, and delete, so can implement with either a Set AVL
Tree or a hash table. Lastly, P requires O(n) build, and O(log n)
insert and delete max, so either a Max-Heap or a Sequence AVL
Tree augmented with subtree max items can be used. Note that
removing an item from a Sequence AVL Tree via a pointer to its
node is exactly the same as deleting the item after being found by
index. Removing an item from a Max-Heap by index is not natively
supported, but uses the same technique as removing the root:
swap the item with the last leaf (the last item in the array), remove
the item, and then swap the moved item up or down the tree to
restore the Max-Heap property.

Problem 5. Robot Wrangling

Dr. Squid has built a robotic arm from n+1 rigid bars called links,
each connected to the one before it with a rotating joint (n joints in
total). Following standard practice in robotics3, the orientation of
each link is specified locally relative to the orientation of the
previous link. In mathematical notation, the change in orientation
at a joint can be specified using a 4 × 4 transformation matrix. Let
M = (M0, . . . , Mn1) be an array of transformation matrices
associated with the arm, where matrix Mk is the change in
orientation at joint k, between links k and k + 1.

Programminghomeworkhelp.com
To compute the position of the end effector4, Dr. Squid will need
the arm’s Q full transformation: n-1 the ordered matrix product of
the arm’s transformation matrices, k=0 Mk = M0 ·M1 · . . . ·Mn-1.
Assume Dr. Squid has a function matrix multiply(M1,M2) that
returns the matrix product5 M1 × M2 of any two 4 × 4
transformation matrices in O(1) time. While tinkering with the arm
changing one joint at a time, Dr. Squid will need to re-evaluate this
matrix product quickly. Describe a database to support the
following worst-case operations to accelerate Dr. Squid’s workflow:
initialize(M) Initialize from an initial input configuration M in
O(n) time.
update joint(k,M) Replace joint k’s matrix Mk with matrix M in
O(log n) time.
full Return the arm’s current full transformation in
transformation() O(1) time.

Solution:

Store the matrices in a Sequence AVL tree T, where every node v

stores a matrix v.M and is augmented with v.P: the ordered product
of all matrices in v’s subtree. This property at a node v can be
computed in O(1) time from the augmentations of its children.
Specifically, let PL

Programminghomeworkhelp.com
and PR be v.left.P and v.right.P respectively (or the 4 × 4 identity
matrix if the respective left or right child is missing); then v.P = PL ·
v.M · PR which can be computed in O(1) time using the provided
matrix multiply function, so this augmentation can be maintained.
(Note that, because the number of items and traversal order
never changes, AVL behavior is not needed here, since no
operation will change the structure of the tree. So a static binary
tree or even an implicitly represented complete binary tree stored
in an array, as in a binary heap, would suffice.)

Now we support the operations:

• initialize(M): build T from the matrices in worst-case M in O(|

M|) = O(n) time, maintaining the new augmentation from the
leaves to the root.
• update joint(k, M): find the node v containing matrix k in the
traversal order using get at(k) at the root of T in O(log n) time, and
replace v.M with M. Then recompute the augmentations up the
tree in O(log n) time.
• full transformation(): the augmentation stored at the root of T
corresponds exactly to the arm’s full transformation, so simply
return T.root.P in O(1) time.

Problem 6. πz2a Optimization

Programminghomeworkhelp.com
Liza Pover has found a Monominos pizza left over from some big-
TEX recruiting event. The pizza is a disc6 with radius z, having n
toppings labeled 0, . . . , n � 1. Assume z fits in a single machine
word, so integer arithmetic on O(1) such integers can be done in
O(1) time. Each topping i:

• is located at Cartesian coordinates (xi, yi) where xi, yi are integers

from range R = {�z, . . . , z} (you may assume that all coordinates
are distinct), and
• has integer tastiness ti ∈ R (note, topping tastiness can be
negative, e.g., if it’s pineapple7).

Liza wants to pick a point (x0 , y0 ) and make a pair of cuts from
that point, one going straight down and one going straight left, and
take the resulting slice, i.e., the intersection of the pizza with the
two half-planes x ≤ x0 and y ≤ y0 . The tastiness of this slice is the
sum of all ti such that xi ≤ x0 and yi ≤ y0 . Liza wants to find a
tastiest slice, that is, a slice of maximum tastiness. Assume there
exists a slice with positive tastiness.

(a) If point (x0 , y0 ) results in a slice with tastiness t 6= 0, show

there exists i, j ∈ {0, 1, . . . , n � 1} such that point (xi, yj )
results in a slice of equal tastiness t (i.e., a tastiest slice exists
resulting from a point that is both vertically and horizontally
aligned with toppings).

Programminghomeworkhelp.com
Solution:

Pick the largest xi ≤ x0 and the largest yj ≤ y0 . Because t 6= 0, the

slice contains at least one topping, so there exists such toppings i
and j. And since the slice S corresponding to point (xi, yj ) contains
exactly the same toppings as the slice corresponding to (x0 , y0 ),
then slice S also has tastiness t.

(b) To make finding a tastiest slice easier, show how to modify a Set
AVL Tree so that:
• it stores key–value items, where each item x contains a value x.val
(in addition to its key x.key on which the Set AVL is ordered);
• it supports a new tree-level operation max prefix() which returns in
worstcase O(1) time a pair (k∗, prefix(k∗)), where k∗ P is any key
stored in the tree T that maximizes the prefix sum, prefix(k) = {x.val |
x ∈ T and x.key ≤ k} (that is, the sum of all values of items whose
keys are ≤ k); and
• all other Set AVL Tree operations maintain their running times.

Solution:

We augment the Set AVL Tree so that each node v stores three
additional subtree properties: • v.sum: the sum of all item values
stored in v’s subtree, which can be

Programminghomeworkhelp.com
computed in O(1) time by: v.sum = v.left.sum + v.item.val +
v.right.sum, or with zeros for the left and right sums if the
respective children do not exist. • v.max prefix: max{prefix(k) | k ∈
subtree(v)}. We can compute the max prefix in the subtree in O(1)
time by comparing three values:

v.max_prefix = max(
v.left.max_prefix,
# left
v.left.sum + v.item.val,
# middle
v.left.sum + v.item.val + v.right.max_prefix)
# right

where augmentations are considered zero on non-existent nodes.

• v.max prefix key: arg max{prefix(k) | k ∈ subtree(v)}. We can

compute the maximizing key in O(1) time based on which of the
three cases is maximum in the above computation: key is
v.left.max prefix key if the left is maximizing, v.item.key if the
middle is maximizing, and v.right.max prefix key if the right is
maximizing.

Because these augmentations can be computed locally in O(1)

time, they can be in O(1) time via the augmentations stored at the
root.

Programminghomeworkhelp.com
maintained without effecting the running times of the normal Set
AVL Tree operations.

support T.max prefix(), simply return

(T.root.max prefix, T.root.max prefix key)

(c) Using the data structure from part (b) as a black box,
describe a worst-case O(n log n)-time algorithm to return a
triple (x, y,t), where point (x, y) corresponds to a slice of
maximum tastiness t.

Solution:

Sort the input topping points by their x coordinates in O(n log n)

time (e.g., using merge sort), and initialize the data structure T
from part (b), initially empty. Then for each topping (xi, yi, ti),
insert it into T as a key-value item with key yi and value ti in O(log
n) time, and then evaluate the max prefix (y∗ , t∗ ) in T . The max
prefix t ∗ is then by definition the maximum tastiness of any slice
with x coordinate xi, specifically the slice corresponding to the
point (xi, y∗ ). By repeating this procedure for each topping
sorted by x, we can compute the maximum tastiness of any slice
at xi for every xi in O(n log n) time (along with its associated
point). Since some slice of maximum tastiness exists with an x

Programminghomeworkhelp.com
coordinate at some xi for i ∈ {0, . . . , n � 1}, as argued in part (a),
then taking the maximum of all slices found in O(n) time will
correctly return a tastiest slice possible.

(ci) Write a Python function tastiest slice(toppings) that

implements your algorithm from part (c), including an
implementation of your data structure from part (b). You can
download a code template containing some test cases from the
website.

Solution:

1 class Part_B_Node(BST_Node):
2 def subtree_update(A):
3 super().subtree_update()
4 A.sum = A.item.val # sum
5 if A.left: A.sum += A.left.sum
6 if A.right: A.sum += A.right.sum
7 left = -float(’inf’) # max prefix
8 right = -float(’inf’)
9 middle = A.item.val
10 if A.left:

Programminghomeworkhelp.com
11 left = A.left.max_prefix
12 middle += A.left.sum
13 if A.right:
14 right = middle + A.right.max_prefix
15 A.max_prefix = max(left, middle, right)
16 if left == A.max_prefix: # max prefix key
17 A.max_prefix_key = A.left.max_prefix_key
18 elif middle == A.max_prefix:
19 A.max_prefix_key = A.item.key
20 else:
21 A.max_prefix_key = A.right.max_prefix_key
22
23 class Part_B_Tree(Set_AVL_Tree):
24 def __init__(self):
25 super().__init__(Part_B_Node)
26
27 def max_prefix(self):
28 k = self.root.max_prefix_key
29 s = self.root.max_prefix
30 return (k, s)
31

Programminghomeworkhelp.com
32 def tastiest_slice(toppings):
33 B = Part_B_Tree() # use data structure from part (b)
34 X, Y, T = 0, 0, 0
35 n = len(toppings)
36 toppings.sort(key = lambda topping: topping[0])
37 for (x, y, t) in toppings:
38 B.insert(Key_Val_Item(y, t))
39 (Y_, T_) = B.max_prefix()
40 if T < T_:
41 X, Y, T = x, Y_, T_
42 return (X, Y, T)

Programminghomeworkhelp.com