Introduction to Algorithms

Massachusetts Institute of Technology 6.006 Spring 2020

Instructors: Erik Demaine, Jason Ku, and Justin Solomon Solution: Quiz 3

Solution: Quiz 3
• Do not open this quiz booklet until directed to do so. Read all the instructions on this page.
• When the quiz begins, write your name on the top of every page of this quiz booklet.
• You have 60 minutes to earn a maximum of 60 points. Do not spend too much time on any
one problem. Skim them all first, and work on them in an order that allows you to make the
most progress.
• You are allowed three double-sided letter-sized sheet with your own notes. No calcula-
tors, cell phones, or other programmable or communication devices are permitted.
• Write your solutions in the space provided. Pages will be scanned and separated for grading.
If you need more space, write “Continued on S1” (or S2) and continue your solution on the
referenced scratch page at the end of the exam.
• Do not waste time and paper rederiving facts that we have studied in lecture, recitation, or
problem sets. Simply cite them.
• When writing an algorithm, a clear description in English will suffice. Pseudo-code is not
required. Be sure to argue that your algorithm is correct, and analyze the asymptotic
running time of your algorithm. Even if your algorithm does not meet a requested bound,
you may receive partial credit for inefficient solutions that are correct.
• Pay close attention to the instructions for each problem. Depending on the problem,
partial credit may be awarded for incomplete answers.

Problem Parts Points

0: Information 2 2
1: Pseudo-Circling 3 3
2: Number Scrabble 1 17
3: Limited-Unlimited 1 19
4: Office Hour Optimization 1 19
Total 60

Name:

School Email:
2 6.006 Solution: Quiz 3 Name

Problem 1. [2 points] Information (2 parts)

(a) [1 point] Write your name and email address on the cover page.
Solution: OK!

(b) [1 point] Write your name at the top of each page.

Solution: OK!
6.006 Solution: Quiz 3 Name 3

Please solve problems (3), (4), and (5) using dynamic programming. Be sure to define a set
of subproblems, relate the subproblems recursively, argue the relation is acyclic, provide base
cases, construct a solution from the subproblems, and analyze running time. Correct but inefficient
dynamic programs will be awarded significant partial credit.

Problem 2. [3 points] Pseudo-Circling

Indicate whether the given running times of each of problems (3), (4), and (5) are polynomial or
pseudopolynomial by circling the appropriate word below. One can answer this question without
actually solving problems (3), (4), and (5). (1 point each)

(a) Problem 3: Number Scrabble Polynomial Pseudopolynomial

Solution: Polynomial

(b) Problem 4: Limited-Unlimited Polynomial Pseudopolynomial

Solution: Pseudopolynomial

(c) Problem 5: Office Hour Optimization Polynomial Pseudopolynomial

Solution: Polynomial
4 6.006 Solution: Quiz 3 Name

Problem 3. [17 points] Number Scrabble

Number Scrabble is a one-player game played on an array T = [t0 , . . . , tn−1 ] of n positive inte-
gers. There is a list P = {(p0 , v(p0 )), . . . , (pm−1 , v(pm−1 ))} of m unique playable words, where
playable word pi is a non-empty array of at most 10 positive integers and v(pi ) is the positive in-
teger value of pi . The objective of the game is to find a gameplay S — a list of non-overlapping
subarrays
P (i.e., substrings) of T , each a playable word — where S has maximum total value,
s∈S v(s). For example, if
T = [1, 5, 2, 4, 1] and P = {([2], 3), ([1], 1), ([5, 2], 8), ([1, 2], 12), ([1, 5], 2)},
then S1 = ([1, 5], [2], [1]), S2 = ([1], [5, 2], [1]), and S3 = ([1], [2], [1]) are all valid gameplays,
with total values 6, 10, and 5 respectively. Note playable word [1, 2] cannot exist in any gameplay
of T , since [1, 2] is not a contiguous subarray of T . Given T and P , describe an O(n + m)-time
algorithm to return a gameplay of maximum total value.
Solution: To solve this problem, it would be useful to be able to check whether a particular array
of at most 10 positive integers is a playable word. Construct an empty hash table D and insert
each pi for i ∈ {0, . . . , m − 1} into D, mapping to its value v(pi ). Each hash table insertion takes
expected constant time (as each pi has constant size), so constructing D takes expected O(m) time.
Now we solve the problem via dynamic programming.

1. Subproblems
• x(i): the maximum total value of any gameplay on suffix T [i :] for i ∈ {0, . . . , n}
2. Relate
• Left-most playable word either starts with ti or it does not
⎧ti , word may have any length in {1, . . . , 10} (Guess!)⎫
• If playable word starts with
⎨ j ∈ {0, . . . , 10} and ⎬
• x(i) = max {x(i + 1)} ∪ D[T [i : i + j]] + x(i + j) i + j ≤ n and
T [i : i + j] ∈ D
⎩ ⎭
3. Topo
• x(i) only depends on subproblems with strictly larger i, so acyclic
4. Base
• x(n) = 0 (empty gameplay admits no value)
5. Original
• Solve subproblems via recursive top down or iterative bottom up
• x(0) is the maximum value of any gameplay on T
• Store parent pointers to reconstruct an optimal gameplay
6. Time
• # subproblems: n + 1 = O(n)
• Work per subproblem: expected O(1)
• Together with hash table construction, yields expected O(n + m) time
• (See scratch S2 for common mistakes)
6.006 Solution: Quiz 3 Name 5

Problem 4. [19 points] Limited-Unlimited

Given two sets of integers A and B, a limited-unlimited sequence of A and B is any sequence
S of integers such that each integer s ∈ S appears in either A or B, and if s appears in A then s
appears at most once in S. Given a target sum m and two disjoint sets A and B, each containing
exactly n distinct positive integers, describe an O(nm)-time algorithm
P to determine whether m is
the sum of any limited-unlimited sequence S of A and B, i.e., m = s∈S s.
Solution:

1. Subproblems
• Fix an arbitrary order on A = (a0 , . . . , an−1 ) and B = (b0 , . . . , bn−1 )
• xA (i, k): Boolean whether k is sum of any subset of suffix of A[i :] (without repeats)
• xB (i, k): Boolean whether k is sum of any subset of suffix of B[i :] (allowing repeats)
• for i ∈ {0, . . . , n}, k ∈ {0, . . . m}
2. Relate
• Either use ai once or not (cannot use again)
 
xA (i + 1, k − ai ) if ai ≤ k
• xA (i, k) = OR
xA (i + 1, k) always
• Either use bj once or not (but may use again)
 
xB (i, k − bj ) if bj ≤ k
• xB (i, k) = OR
xB (i + 1, k) always
3. Topo
• Subproblems xA (i, k) and xB (i, k) each depend only on subproblems
with strictly smaller k − i, so acyclic
4. Base
• xs (i, 0) = True for s ∈ {A, B}, i ∈ {0, . . . , n} (can always make zero sum)
• xs (n, k) = False for s ∈ {A, B}, k ∈ {1, . . . , m} (cannot make positive sum)
5. Original
• Solve subproblems via recursive top down or iterative bottom up
• Original is whether a subset of A and a possibly-repeating subset of B sum to m
• i.e., OR{AND{xA (0, k), xB (0, m − k)} | k ∈ {0, . . . , m}}
6. Time
• # subproblems: (n + 1)(m + 1) = O(nm)
• Work per subproblem: O(1)
• Original takes O(m) time
• O(nm) running time in total
• (See scratch S2 for common mistakes)
6 6.006 Solution: Quiz 3 Name

Problem 5. [19 points] Office Hour Optimization

Class 0.660 (Algorithms for Introductions) is holding online office hours to help students on three
problems — a, b, and c — in three corresponding breakout rooms. The TAs want to develop a
‘Sort Bot’ to effectively assign each student to a single room at the start of office hours. Assume
there are 3n students, where each student i has known nonnegative integer benefit ai , bi , and ci for
being assigned to the room for problem a, b, and c, respectively.
Describe an O(n3 )-time algorithm to determine whether it is possible to assign the students equally
to the three breakout rooms (i.e., n students to each room) while providing strictly positive help to
every student, and if possible, return the maximum total benefit to students of any such assignment.
Note that the assignment must not assign a student to a room for which they would get zero benefit.
Solution:

1. Subproblems
• Let the students be i ∈ {1, . . . , 3n}
• x(i, j, k): the maximum benefit assigning students {1, . . . , i + j + k} to breakout rooms,
with i students to breakout a, j students to breakout b, and k students to breakout c,
where each student is assigned to a breakout room with strictly positive benefit
(or equals −∞ if no such assignment is possible)
• for i, j, k ∈ {0, . . . , n}
2. Relate
• Must assign student i + j + k to some room (Guess!)
⎧ ⎫
⎨ ai+j+k + x(i − 1, j, k) if i > 0 and ai+j+k > 0, ⎬
• x(i, j, k) = max{−∞} ∪ bi+j+k + x(i, j − 1, k) if j > 0 and bi+j+k > 0,
ci+j+k + x(i, j, k − 1) if k > 0 and ci+j+k > 0
⎩ ⎭

3. Topo
• Subproblem x(i, j, k) depends only on strictly smaller i + j + k, so acyclic
4. Base
• x(0, 0, 0) = 0 (no benefit to assigning zero students)
5. Original
• Solve subproblems via recursive top down or iterative bottom up
• x(n, n, n) is the maximum benefit to assign all students evenly to rooms
6. Time
• # subproblems: (n + 1)3 = O(n3 )
• Work per subproblem: O(1)
• O(n3 ) running time in total
• (See scratch S2 for common mistakes)
6.006 Solution: Quiz 3 Name 7

SCRATCH PAPER 1. DO NOT REMOVE FROM THE EXAM.

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: (Problem 3: Number Scrabble)

• Not checking whether substrings of T are playable

• A relation that assumes a gameplay must include every number in T
• Not accounting for time to read P in running time
• Not using parent pointers to return a gameplay

Common Mistakes: (Problem 4: Limited-Unlimited)

• Not allowing integers in B to be used more than once

• Trying to store or maintain an arbitrary subset (can have exponential state)

Common Mistakes: (Problem 5: Office Hour Optimization)

• Poor communication of subproblems (not specifying suffix/prefix, etc.)

• Defining O(n4 ) subproblems without arguing that only O(n3 ) are needed
• Allowing more than n students in a room, or assigning students to rooms with no benefit
• Pseudopolynomially many subproblems with Boolean output (must be polynomial in n)
• Taking the maximum over an OR
8 6.006 Solution: Quiz 3 Name

SCRATCH PAPER 2. DO NOT REMOVE FROM THE EXAM.

You can use this paper to write a longer solution if you run out of space, but be sure to write
“Continued on S2” on the problem statement’s page.
MIT OpenCourseWare
https://ocw.mit.edu

6.006 Introduction to Algorithms

Spring 2020

For information about citing these materials or our Terms of Use, visit: https://ocw.mit.edu/terms