Problem 1.

Decision Problems
For each of the following questions, circle either T (True) or F (False),
and briefly justify your answer in the box provided (a single sentence or
picture should be sufficient). Each problem is worth 4 points: 2 points for
your answer and 2 points for your justification. If you leave both answer
and justification blank, you will receive 1 point.

(a) T F 22n ∈ Θ(2n ).

, then T (n) =

Solution: False. This statement is O(n ).

equivalent to saying k2
∈ O(k) for k = 2n . Constants in exponents matter
asymptotically!

(b) T F If T (n) = T n + n and T (1) = Θ(1)

Solution: False. This is an example of Case II of Master

Theorem, since a = 9 , b = 3 , f (n) = n2 and n2 = Θ(nlog 3/2
9/4
log0 n). Thus, the recurrence evaluates to T (n) = Θ(n 2
log n), which is not O(n 2 ).

(c) T F Performing an O(1) amortized operation n times on an initially

empty data structure takes worst-case O(n) time.
Solution: True. This is the defintion of
amortization.

© 2022 All Rights Reserved . Programming Exam Help

(d) T F Given an array A containing n comparable items, sort A using
merge sort. While sorting, each item in A is compared with O(log n)
other items of A.
Solution: False. As a counter example, during the final merge
step between two sorted halves of the array, each of size Θ(n), a
single item from one array may get compared to all the items from
the other list.
(e) T F Given a binary min-heap storing n items with comparable
keys, one can build a Set AVL Tree containing the same items
using O(n) comparisons.

Solution: False. If such an algorithm A existed, we would be

able to sort an array of comparable items in O(n) time, which
would contradict the Ω(n log n) comparison sort lower bound.
Specifically, we could build a binary min-heap from the array
using O(n) comparisons, use A to construct a Set AVL Tree in
O(n) comparisons, and then return its traversal order.

(f) T F Given a directed graph G = (V, E), run breadth-first search

from a vertex s ∈ V . While processing a vertex u, if some v ∈
Adj + (u) has already been processed, then G contains a directed
cycle.

Solution: False. BFS can’t be used to find directed cycles. A

counterexample is V = {s, a, b, t} and E = {(s, t), (s, a), (a, b),
(b, t)}. Running BFS from s will first process vertices in levels
{s}, then {a, t}, then {b}. When processing vertex b, vertex t ∈
Adj + (b) has already been processed, yet G is a DAG.

© 2022 All Rights Reserved . Programming Exam Help

(g) T F Run Bellman-Ford on a weighted graph G = (V, E, w) from a vertex s
∈ V . If there is a witness v ∈ V , i.e., δ|V |(s, v) < δ|V |−1(s, v), then v is on
a negative- weight cycle of G.
Solution: False. A witness is only guaranteed to be reachable
from a negative-weight cycle; it may not actually be on a
negative-weight cycle.
(h) T F Floyd–Warshall and Johnson’s Algorithm solve all-pairs shortest paths
in the same asymptotic running time when applied to weighted complete graphs,
i.e., graphs where every vertex has an edge to every other vertex.

Solution: True. A complete graph is dense, i.e., |E| = Θ(|V |

2
), so Johnson’s algorithm runs in O(|V |2 log |V | + |V ||E|) =
O(|V |3) time, which is the same as Floyd–Warshall.
(i) T F If there is an algorithm to solve 0-1 Knapsack in polynomial time, then
there is also an algorithm to solve Subset Sum in polynomial time.

Solution: True. Subset Sum is the special case of 0-1 Knapsack.

Specifically, one can (in linear time) convert an instance (A, T ) of
Subset Sum into an equiv- alent instance of 0-1 Knapsack, with an
item i for each integer ai ∈ A having size s i = ai and value v i = ai,
needing to fill a knapsack of size T ; and then solve the instance via
the polynomial-time algorithm for 0-1 Knapsack.

(j) T F Suppose a decision problem A has a pseudopolynomial-time

algorithm to solve A. If P 6= NP, then A is not solvable in polynomial
time.
Solution: False. A problem could have a pseudopolynomial-
time algorithm
and a polynomial-time algorithm. In fact, any polynomial-
time algorithm is also a pseudopolynomial-time algorithm!
© 2022 All Rights Reserved . Programming Exam Help
Problem 3. Sorting Sorts
(a)An integer array A is k-even-mixed if there are exactly k even
integers in A, and the odd integers in A appear in sorted order. Given
a k-even-mixed array A containing n distinct integers for k = dn/ lg
ne, describe an O(n)-time algorithm to sort A.
Solution: Scan through A and put all even integers in order into an
array A E and all odd integers in order into an array A O (where |A E | =
k and |AO| = n − k). A O is sorted by definition, and we can sort A E in
O(k log k) = O((n/ lg n) log(n/ lg n)) = O(n) time, e.g., via merge
sort. Then we can merge sorted A E and A O back into A in O(n) time
using the merge step of merge sort, using O(n) time in total.
Common Mistakes:
•Using insertion sort
•Splitting into a non-constant number of subarrays and trying to
merge
•Using binary search to insert evens into odds (but with linear
shifts)
•Using radix or counting sort

(b)let A be an array of n pairs of positive integers (x i , y i ) with x i , y i < n2

for all i ∈ {0, . . . , n − 1}. The power of pair (x, y) is the integer x +
ny . Describe an O(n)-time algorithm to sort the pairs in A increasing by
power.
Solution: First note that x < n y for any integer y > 1 and for any x ∈
{0, . . . , n2 −1}. Scan through A and put all pairs having y = 1 into
array A 1 , and all other pairs into array A 2 . Sort A 1 directly by computing
and comparing their respective powers x + n. Since these values are
bounded above by O(n 2 ), sort A 1 in O(n) time using Radix sort. To sort
A 2 , use tuple sort, sorting first by x values and then by y values (since
power is more sensitive to changes in y). Since the x and y values are
both bounded above by O(n 2 ), we can use Radix
© 2022 All Rights Reserved . Programming Exam Help
 sort for tuple sort’s stable sorting algorithm to sort A 2 in O(n) time. Then
merge A 1 and A 2 back into A in O(n) time using the merge step of merge
sort, using O(n) time in total.
Common Mistakes:
•Not handling y = 1 (x may be larger or smaller than n1 )
•Explicitly computing powers (which may have exponential size)
•Concatenating instead of merging two overlapping lists

Problem 4. Pythagorean Quad

A Pythagorean Quad consists of four integers (a, b, c, d) such that d = √a2
+ b2 + c2. Given an array A containing n distinct positive integers,
describe an O(n2 )-time algorithm to determine whether four integers from
A form a Pythagorean Quad, where integers from A may appear more than
once in the Quad. State whether your running time is worst-case, expected,
and/or amortized.
Solution: First, we observe that it suffices to find (a, b, c, d) such that a2 +
b2 = d2 − c2. Let P be the set of n2 ordered pairs of integers from A, where
integers in A may be repeated in a pair. Construct an empty hash table H,
and for each pair (a, b) ∈ P , compute and insert value a2 + b2 into H. Then
for each pair (c, d) ∈ P , compute and lookup value d2 − c2 in H. If the value
is in H, then some a2 + b2 equals some d2 − c2, so return that a Pythagorean
Quad exists. Otherwise, if no d2 − c2 exists in H, then return that a
Pythagorean Quad does not exist. Each a2 + b2 or d2 − c2 value takes
constant time to compute, so computing them all takes worst-case O(n 2 )
time, while inserting them into or looking them up in the hash table takes
expected O(n 2 ) time, so this algorithm runs expected in O(n 2 ) time in total.
Common Mistakes:
•Computing non-integers involving logarithms or square roots
•Saying a worst-case running time is amortized
© 2022 All Rights Reserved . Programming Exam Help
 •Trying to write an incorrect dynamic program
•Trying to write an incorrect four-finger algorithm

Problem 5. Animal Counting

PurpleRock Park is a wildlife reserve, divided into zones, where each
zone has a park ranger who records current sightings of animals of
different species over time. Old animal sightings are periodically removed
from the database. A species s is common if current park records contain at
least 100 sightings of species s within any single zone of the park.
Describe a database to store animal sightings, supporting the following
four operations, where n is the number of sightings stored in the database
at the time of the operation. State whether your running times are worst-
case, expected, and/or amortized.
Solution: To implement the database, maintain the following data
structures:
•A hash table H mapping each species s to a Set AVL tree T s
•Each Set AVL Tree T s stores pairs (i, c i ) of zone numbers i and the
count ci representing the number of sightings of species s in zone i,
keyed by zone number.
•Augment each node x in each T s by the maximum number of sightings
x.m of any zone in the subtree of x. x.m can be maintained in O(1)
time from the augmentations of x’s children, specifically x.m =
max{x.left.m, x.key, x.right.m}.
•A doubly-linked list L of all current sightings (s, i) in the order in
which they were added to the database (oldest at the front).
initialize() Initialize an empty database in O(1) time
add sighting(s, i) Record a newest sighting of species s in zone i in O(log n) time
remove oldest() Remove the oldest sighting stored in the database in O(log n) time

is common(s) Return whether species s is common based on sightings

that have not yet been removed from the database in O(1) time
To implement initialize(), initialize an empty H and empty L in worst-
case O(1) time.
To implement add sighting(s, i), lookup s in H to find T s in expected
O(1) time (if s does not exist in H, insert s mapping to an empty T s in
expected amortized O(1) time). Then find zone i in Ts . If zone i is not
in Ts , insert (i, 1) into Ts . Otherwise, i is in T s , so remove (i, c i ) from
T s and reinsert (i, ci + 1). It takes worst-case O(log n) time to remove
or insert items from T s while maintaining augmentations (since at most
n sightings could exist for species s). Lastly, Insert (s, i) to the back of
L in worst-case O(1) time. Thus this operation takes O(log n) expected
amortized time, and maintains the invariants of the database directly.
To implement remove oldest(), remove the oldest pair (s, i) from the
front of L in worst-case O(1) time. Lookup s in H to find T s in
expected O(1) time; then lookup i in T s and decrease ci by one. If ci is
decreased to zero, remove i from Ts . If T s becomes empty, remove s
from H in expected amortized O(1) time. This operation takes O(log n)
expected amortized time, and maintains the invariants of the database
directly.
To implement is common(s), simply lookup s in H and return whether s
is in H and the stored max at the root of T s is 100 or greater in expected
O(1) time. This operation is correct based on the invariants of the data
structure.
Common
Problem 6. Mistakes:
Limited Continued
Connectionson S1
For any weighted graph G = (V, E, w) and integer k, define Gk to be
the graph that results from removing every edge in G having weight k
or larger.
Given a connected undirected weighted graph G = (V, E, w), where
every edge has a unique
integer weight, describe an O(|E| log |E|)-time algorithm to determine
the largest value of k such

© 2022 All Rights Reserved . Programming Exam Help

that G k is not connected.
Solution: Construct an array A containing the |E| distinct edge weights in
G, and sort it in O(|E| log |E|) time, e.g., using merge sort. We will binary
search to find k. Specifically, consider an edge weight k0 in A (initially the
median edge weight), and run a reachability algorithm (e.g., Full-BFS or
Full-DFS) to compute the reachability of an arbitrary vertex x ∈ V in O(|
E|) time. If exactly |V | vertices are reachable from x, then Gk 0 is connected
and k > k0; recurse on strictly larger values for k0. Otherwise, Gk 0 is not
connected, so k ≤ k0; recurse on non-strictly smaller values for k0. By
dividing the search range by a constant fraction at each step (i.e., by always
choosing the median index weight of the unsearched space), binary search
will terminate after O(log |E|) steps, identifying the largest value of k such
that G k is not connected. This algorithm takes O(|E| log |E|) time to sort,
and computes reachability of a vertex in O(|E|) time, O(log |E|) times, so
this algorithm runs in O(|E| log |E|) time in total.
Common Mistakes:
•Filtering linearly on all edge weights, rather than using binary search
•Using Dijkstra/Bellman-Ford to inefficiently solve reachability
•Simply stating ‘Use Dijkstra’

© 2022 All Rights Reserved . Programming Exam Help

Problem 7. On the Street
Friends Dal and Sean want to take a car trip across the country from Yew
Nork to Fan Sancrisco by driving between cities during the day, and
staying at a hotel in some city each night. There are n cities across the
country. For each city ci, Dal and Sean have compiled:
•the positive integer expense h(c i ) of staying at a hotel in city ci for
one night; and
•a list L i of the at most 10 other cities they could drive to in a single
day starting from city ci, along with the positive integer expense g(ci ,
c j ) required to drive directly from ci to c j for each c j ∈ L i .
Describe an O(nd)-time algorithm to determine whether it is possible for
Dal and Sean to drive from Yew Nork to Fan Sancrisco in at most d
days, spending at most b on expenses along the way.
Solution: Let C = {c 0 , . . . , cn−1 }, and let cs denote Yew Nork and let ct
denote Fan Sancrisco. Construct a graph G with:
•a vertex (c i , d0) for each city ci ∈ C and day d0 ∈ {0, . . . ,
d}, representing staying the night in city ci on the night
before day d0; and
•a directed weighted edge ((c i , d0), (c j , d0 + 1)) with weight
g(ci, c j ) + h(c j )
for each city ci ∈ C , cj ∈ L i and d0 ∈ {0, . . . , d − 1}.
Then the weight of any path in G from vertex (cs , 0) to any vertex (ct ,
d0) for d0 ∈ {0, . . . , d} corresponds to the expenses incurred along a
driving route from Yew Nork to Fan Sancrisco in at most d days
(assuming they stay the night upon reaching ct; other assumptions are
also okay). G is acyclic, since each edge always connects a vertex from
a smaller day to a larger day, so run DAG Relaxation to compute single-
source shortest paths from (cs , 0) in G. Then return whether δ((cs , 0),
(ct, d0)) ≤ b for any d0 ∈ {0, . . . d}. G has O(nd) vertices and O(nd)
edges (since)
© 2022 All Rights Reserved . Programming Exam Help
|Li | ≤ 10 for all i ∈ {0, . . . , n − 1}), so DAG relaxation runs in O(nd)
time and checking all destination values takes O(d) time, leading to O(nd)
time in total.
Common Mistakes:
•Not considering paths on fewer than d days (or considering paths on
more than d days)
•Not enforcing staying at a hotel every night
•Not including hotel costs

•Problem 8. RGB Graph

•Let G = (V, E, w) be a weighted directed graph. Let c : V → {r, g, b} be
an assignment of each
vertex v to a color c(v), representing red, green, or blue respectively. For x
∈ {r, g, b},
•let Vx be the set of vertices with color x, i.e., Vx = {v ∈ V | c(v) = x};
and
•let E x be the set of edges outgoing from vertices in Vx , i.e., E x = {(u, v)
∈ E | u ∈ V x }.
Suppose graph G and coloring c have the following properties:
1.Every edge in E either connects two vertices of the same color,
goes from a red vertex to a green vertex, or goes from a green vertex to a
blue vertex.
2.|Vr| = |Er | = O(|V |), and edges in E r have identical positive integer
weight wr .
3.|Vg | = |Eg | = O(|V |0.99), and edges in E g have nonnegative integer
weights.
4.|Vb| = |Eb| = O( p |V |), and edges in E b can have positive or negative
integer weights.

© 2022 All Rights Reserved . Programming Exam Help

Given G, c, a red vertex s ∈ Vr , and a blue vertex t ∈ Vb, describe an O(|V
|)-time algorithm to compute δ(s, t), the minimum weight of any path
from s to t.
Solution: Any path from s to t is a path through edges in E r , followed by
a path through edges in E g , followed by a (possibly empty) path through
edges in E g . So we compute minimum weight distances in G
incrementally, first using edges in E r , then using edges in E g , then edges
in E b .
Step 1: Construct unweighted graph G0 = (V 0, E0 ) composed of the
edges E0 = E r and the

0 S(u,v)∈E
vertices appearing in those edges, {u, v} (which contains
specifically V = vertices from
Vr and Vg ). Run breadth-first search from s in G0 to compute
unweighted distances. Then the r
minimum weight distance in G from s to any green vertex in V 0 ∩ Vg is
wr times the unweighted

distance computed. G0 has size O(|V |), so this step takes O(|V |) time.
Step 2: Now construct weighted graph G00 = (V 00, E00) composed of
vertex s with a new directed

© 2022 All Rights Reserved . Programming Exam Help

edge to each green vertex in V 0 ∩ Vg weighted by its distance found in Step
1 (i.e., the minimum weight of any path from s to that vertex), along with
weighted edges E g and the vertices appearing in those edges. All the
weights in G00 are positive, so run Dijkstra from s in G00 to compute
minimum weight distances. Then the computed distance to any blue vertex
v in V 00 ∩ Vb is the minimum weight of any path from s to v in G that
traverses only red or green edges. G00 has size O(1 + |Vg | + |Eg |) = O(|V |
0.99
), so this step takes O(|V |0.99 log |V |0.99) = O(|V |) time.
Step 3: Now construct a weighted graph G000 = (V 000, E000) composed of
vertex s with a new directed edge to each blue vertex in V 00 ∩ Vb weighted
by its distance found in Step 2 (i.e., the minimum weight of any path from
s to that vertex), along with weighted edges E b and the vertices appearing
in those edges. Weights in G000 may be positive or negative, so run Bellman-
Ford from s in G000 to compute weighted minimum weight distances. Then
the computed distance to t is the minimum
weight of any path from s to t in G, as desired. G000 has size O(1 + |Vb| +
pp p
this
|E b |) step
= O(takes O(so |V | |V |) = O(|V |) time, leading to O(|V |) time in
|V |),
total.
Common Mistakes: Continued on S1.
Problem 9. Separated Subsets
For any set S of integers and for any positive integers m and k, an (m, k)-
separated subset of S
is any subset S0 ⊆ S such that S0 sums to m and every pair of distinct
integers a, b ∈ S0 satisfies

|a − b| ≥ k. Given positive integers m and k, and a set S containing n

distinct positive integers,

describe an O(n2 m)-time algorithm to count the number of (m, k)-

separated subsets of S.
(When solving this problem, you may assume that a single machine word
is large enough to hold any integer computed during your algorithm.)
Solution:
describe an O(n2 m)-time algorithm to count the number of (m, k)-
separated subsets of S.
(When solving this problem, you may assume that a single machine word
is large enough to hold any integer computed during your algorithm.)
Solution:
1.Subproblems
•First sort the integers in S increasing into array A in O(n log n) time,
e.g., via merge sort
•where A = (a0 , . . . , an −1 )
•x(i, j): the number of (j, k)-separated subsets of suffix A[i :]
•for i ∈ {0, . . . , n} and j ∈ {0, . . . , m}
2.Relate
•Sum the number of (j, k)-separated subsets using A[i] with the ones
that do not use A[i]
•If A[i] ≤ j is used:
–Then no integer in A[i :] smaller than A[i] + k may be used
–Let f (i) be the smallest index greater than i such that A[f (i)] −
A[i] ≥ k
–Then recrusively count x(f (i), j − A[i])
x(f (i), j − A[i]) if
•x(i, j ) =P x(i + 1, j )
A[i] ≤ j,
3. Topo always
•Otherwise, A[i] is not used and we can
recursively count x(i + 1, j)

© 2022 All Rights Reserved . Programming Exam Help

 •Subproblem x(i, j) only depends on strictly larger i, so acyclic
4.Base
•x(n, 0) = 1, the empty subset can always be acheived
•x(n, j) = 0 for j > 0, empty sets cannot sum to a positive number
5.Original
•x(0, m), the number of (m, k)-separated subsets of A
6.Time
•# subproblems: (n + 1)(m + 1) = O(nm)
•Work per subproblem: O(n) to find f (i) by linear scan
•O(n m) time in total
2
•(Note that it is possible to compute f (i) in O(log n) time via binary
search, or in amor- tized O(1) time from f (i − 1), but these
optimizations are not necessariy for full points.)
Common Mistakes: Continued on S1.

Problem 10. A Feast for Crowns

Ted Snark is arranging a feast for the Queen of Southeros and her guests,
and has been tasked with seating them along one side of a long banquet
table.
•Ted has a list of the 2n guests, where each guest i has a known
distinct positive integer f i
denoting the guest’s favor with the Queen.
•Ted must seat the guests respectfully: the Queen must be seated in the
center with n guests on either side so that guests’ favor monotonically
decreases away from the Queen, i.e., any guest seated between a guest
i and the Queen must have favor larger than f i .

© 2022 All Rights Reserved . Programming Exam Help

•Additionally, every guest hates every other guest: for every two guests i,
j, Ted knows the
positive integer mutual hatred d(i, j) = d(j, i) between them.
Given Ted’s guest information, describe an O(n3 )-time algorithm to
determine a respectful seating order that minimizes the sum of mutual
hatred between pairs of guests seated next to each other. Significant
partial credit will be awarded to correct O(n4 )-time algorithms.
Solution:
1.Subproblems
•Sort the guests increasing by favor in O(n log n) time into F =
(f 0 , . . . , f 2 n−1 )
•Any partition of F into two length-n subsequences corresponds to
a respectful seating
•x(i, j L , j R , n L ): minimum total hatred of adjacent guests
possible by respectfully seating the n − i guests from suffix F
[i :] next to the Queen, with n L guests to the left and n R = (n
− i) − n L guests to the right, where guest j L < i has already been
seated n L + 1 places to the left, and guest j R < i has already
been seated n R + 1 places to the right.
•for i ∈ {0, . . . , 2n}, j L , j R ∈ {−1, . . . , 2n − 1} and n L ∈
{0, . . . , n}
where either j L = i − 1 or j R = i − 1
•Let d(−1, i) = d(i, −1) = 0 for all i ∈ {0, . . . , 2n − 1} (no
hatred at the end of table)
2.Relate
•Guess whether guest i is seated on the right or left

© 2022 All Rights Reserved . Programming Exam Help

 •Sitting next to j L costs hatred d(i, j L ); sitting next to j R
costs
•x(i,hatred
j , j d(i,
, n j)R ) d(i, j ) + x(i + 1, i, j , n − 1)
LRL L R L if n L > 0,
= min d(i, j R ) + x(i + 1, j L , i, n L ) if (n − i) −
nL > 0

3.Topo: Subproblem x(i, j L , j R , n L ) only depends on strictly larger i, so

acyclic
4.Base: x(2n, j L , j R , 0) = 0 for all j L , j R ∈ {0, . . . , 2n} (no hatred if no
guests)
5.Original: x(0, −1, −1, n), min hatred of adjacent guests by respectfully
seating all guests
6.Time
•# subproblems: though there are four parameters, there are only O(n 3 )
subproblems for which either j L = i − 1 or j R = i − 1
•Work per subproblem: O(1), so O(n 3 ) time in total
Common Mistakes: Continued on S1.
You can use this paper to write a longer solution if you run out of space,
but be sure to write “Continued on S1” on the problem statement’s page.

Common Mistakes: (for Problem 5)

•Not removing records for sightings or zones containing zero sightings
•Not accounting for existence or non-existence of a key in a data structure
•Algorithm is linear in number of zones or does account for zones at all
•Forgetting to say amortized for dynamic hash table operations
•Confusing Sequence/Set AVL Trees, or dynamic/direct-access arrays
•Not maintaining or updating number of sightings per zone per species
correctly

© 2022 All Rights Reserved . Programming Exam Help

Common Mistakes:
•Correctly finding shortest paths within each color, but not connecting
them properly
•Assuming an optimal path from s to t goes through the green vertex
closest to s
•Solving APSP on the red or green graph (inefficient)
•Trying to apply DAG relaxation to a possibly cyclic graph
•Assuming that if |V | = |E|, graph has at most one cycle (only true if
connected)
Common Mistakes:
•Maintaining a subset of used items (yields exponential state)
•Unconrstrained subproblem for relation that relies on a constraint
•Solving the decision problem rather than the counting problem (or max
instead of sum)
•Missing a base case
Common Mistakes:
•Not ensuring that n guests are seated to either side of Queen
•Not keeping track of guests on either end
•Defining Ω(n 3 ) subproblems whose parameters are not independent
•Maintaining a subset of used items (yields exponential state)

© 2022 All Rights Reserved . Programming Exam Help