Solutions to Homework 1 Practice Problems

[DPV] Problem 6.4 – Dictionary lookup

Solution: Once again, the subproblems consider prefixes but now the table
just stores TRUE or FALSE. For 0 ≤ i ≤ n, let E(i) denote the TRUE/FALSE
answer to the following problem:
E(i): Can the string s1 s2 . . .si be broken into a sequence of valid words?
Whether the whole string can be broken into valid words is determined
by the boolean value of E(n).
The base case E(0) is always TRUE: the empty string is a valid string. The
next case E(1) is simple: E(1) is TRUE iff dict(s[1]) returns TRUE. We will
solve subproblems E(1), E(2), . . . , E(n) in that order.
How do we express E(i) in terms of earlier subproblems E(0), E(1), E(2), . . . , E(i−
1)? We consider all possibilities for the last word, which will be of the form
sj . . .si where 1 ≤ j ≤ i. If the last word is sj . . .si , then the value of E(i)
is TRUE iff both dict(sj . . .si ) and E(j − 1) are TRUE. Clearly the last word
can be any of the i strings s[j . . . i], 1 ≤ j ≤ i, and hence we have to take an
“or” over all these possibilities. This gives the following recurrence relation
E(i) is TRUE iff the following is TRUE for at least one j ∈ [1, . . . , i]: {dict
(s[j . . . i]) is TRUE AND E(j − 1) is TRUE }.
That recurrence can be expressed more compactly as the following where
∨ denotes boolean OR and ∧ denotes boolean AND:
_
E(i) = {dict(s[j . . . i]) ∧ E(j − 1)} .
j∈[1,...,i]

Finally, we get the following dynamic programming algorithm for checking

whether s[·] can be reconstituted as a sequence of valid words: set E(0) to
TRUE. Solve the remaining problems in the order E(1), E(2), E(3), . . . , E(n)
using the above recurrence relation.
The second part of the problem asks us to give a reconstruction of the
string if it is valid, i.e., if E(n) is TRUE. To reconstruct the string, we add an
additional bookkeeping device here: for each subproblem E(i) we compute
an additional quantity prev(i), which is the index j such that the expression
dict(sj , . . . , si )∧E(j−1) is TRUE. We can then compute a valid reconstruction
by following the prev(i) “pointers” back from the last problem E(n) to E(1),
and outputting all the charaters between two consecutive ones as a valid word.
Here is the pseudocode.

1
Algorithm 1 Dictionary(S[1 . . . n])
E(0) = TRUE.
for i = 1 to n do
E(i) = FALSE.
for j = 1 to i do
if E(j − 1) = TRUE and dict(sj . . .si ) = TRUE then
E(i) = TRUE
prev(i) = j
end if
end for
end for
return E(n)

To output the partition into words after running the above algorithm we
use the following procedure.

Algorithm 2 Reconstruct(S[1 . . . i])

if E(j) = FALSE then
return FALSE
else
return (Reconstruct(S[1 . . . prev(i) − 1]), sprev(i) sprev(i)+1 . . . si )
end if

The above algorithm Dictionary() takes O(n2 ) total time.

2
[DPV] Problem 6.8 – Longest common substring
Solution:
Here we are doing the longest common substring (LCStr), as opposed
to the longest common subsequence (LCS). First, we need to figure out the
subproblems. This time, we have two sequences instead of one. Therefore, we
look at the longest common substring (LCStr) for a prefix of X with a prefix
of Y . Since it is asking for substring which means that the sequence has
to be continuous, we should define the subproblems so that the last letters
in both strings are included. Notice that the subproblem only makes sense
when the last letters in both strings are the same.
Let us define the subproblem for each i and j as:

P (i, j) = length of the LCStr for x1 x2 ...xi with y1 y2 ...yj

where we only consider substrings with a = xi = yj as its last letter.

For those i and j such that xi 6= yj , we set P (i, j) = 0.

Now, let us figure out the recurrence for P (i, j). Assume xi = yj . Say
the LCStr for x1 . . . xi with y1 . . . yj is the string s1 . . . s` where sa = xi = yj .
Then s1 . . . s`−1 is the LCStr for x1 . . . xi−1 with y1 . . . yj−1 . Hence, in this
case P (i, j) = 1 + P (i − 1, j − 1). Therefore, the recurrence is the following:
(
1 + P (i − 1, j − 1) if xi = yj
P (i, j) =
0 if xi 6= yj

The base cases are simple, P (0, j) = P (i, 0) = 0 for any i, j.

The running time is O(nm).

3
Algorithm 3 LCStr(x1 , x2 , . . . , xn , y1 , y2 , . . . , ym )
for i = 0 to n do
P (i, 0) = 0.
end for
for j = 0 to m do
P (0, j) = 0.
end for
for i = 1 to n do
for j = 1 to m do
if xi = yj then
P (i, j) = 1 + P (i − 1, j − 1)
else
P (i, j) = 0
end if
end for
end for
return maxi,j {P (i, j)}

4
[DPV] Problem 6.18 – Making change II
Solution: This problem is very similar to the knapsack problem without
repetition that we saw in class.
First of all, let’s identify the subproblems. Since each denomination is
used at most once, consider the situation for xn . There are two cases, either

• We do not use xn then we need to use a subset of x1 , . . . , xn−1 to form

value v;

• We use xn then we need to use a subset of x1 , . . . , xn−1 to form value

v − xn . Note this case is only possible if xn ≤ v.

If either of the two cases is TRUE, then the answer for the original problem is
TRUE, otherwise it is FALSE. These two subproblems can depend further on
some subproblems defined in the same way recursively, namely, a subproblem
considers a prefix of the denominations and some value.
We define a n × v sized table D defined as:

D(i, j) = {TRUE or FALSE where there is a subset of the coins of

denominations x1 ,...,xi to form the value j.}

Our final answer is stored in the entry D(n, v).

Analogous to the above scenario with denomiation xn we have the follow-
ing recurrence relation for D(i, j). For i > 0 and j > 0 then we have:
(
D(i − 1, j) ∨ D(i − 1, j − xi ) if xi ≤ j
D(i, j) =
D(i − 1, j) if xi > j.

(Recall, ∨ denotes Boolean OR.)

The base cases are D(0, 0) = TRUE and for all j = 1, 2, . . . , v, D(0, j) =
FALSE.
The algorithm for filling in the table is the following.
Each entry takes O(1) time to compute, and there are O(nv) entries.
Hence, the total running time is O(nv).

5
Algorithm 4 Coin Changing II
D(0, 0) = TRUE.
for j = 1 to v do
(0, j) = FALSE.
end for
for i = 1 to n do
for j = 0 to v do
if xi ≤ j then
D(i, j) ← D(i − 1, j) ∨ D(i − 1, j − vi )
else
D(i, j) ← D(i − 1, j)
end if
end for
end for
return D(n, v)

6
[DPV] Problem 6.19 – Making change k
Solution:
Note that, the requirement is we need to use k coins and also we have
unlimited supply of each coin. Therefore, in the subproblem, we should be
able to recover how many coins have been used so far.
Let T (v, i) be TRUE or FALSE whether it is possible to make value v
using exactly i coins. This leads to an O(nkV ) time solution.
Alternatively, we can use a 1-dimensional array.
For 0 ≤ v ≤ V , let

T (v) = minimum number of coins to make value v

The recurrence is

T (v) = min{1 + T (v − xj ) : 1 ≤ j ≤ n, xj ≤ v}
j

Algorithm 5 Coin-k(x1 , x2 , . . . , xn ; V ; k)
T (0) = 0
for i = 1 to V do
T (i) = ∞
for j = 1 to n do
if xj ≤ i and T (i) > 1 + T (i − xj ) then
T (i) = 1 + T (i − xj )
end if
end for
end for
if T (V ) ≤ k then
return TRUE
else
return FALSE
end if

The table is of size O(V ) and each entry takes O(n) time to compute.
Hence the total running time is O(nV ).

7
[DPV] Problem 6.20 – Optimal Binary Search Tree
Solution:
This is similar to the chain matrix multiply problem that we did in class.
Here we have to use substrings instead of prefixes for our subproblem. For
all i, j where 1 ≤ i ≤ j ≤ n, let

C(i, j) = minimum cost for a binary search tree for words pi , pi+1 , . . . , pj .

The base case is when i = j, and then the expected cost is 1 for the search
for word pi , hence C(i, i) = pi . Let’s also set for j < i C(i, j) = 0 since such
a tree will be empty. These entries where i > j will be helpful for simplifying
our recurrence.
To make the recurrence for C(i, j) we need to decide which word to place
at the root. If we place pk at the root then we need to place pi , . . . , pk−1 in
the left-subtree and pk+1 . . . , pj in the right subtree. The expected number
of comparisons involves 3 parts: words pi , . . . , pj all take 1 comparison at
the root , the remaining cost for the left-subtree is C(i, k − 1), and for the
right-subtree it’s C(k + 1, j). Therefore, for i < j we have:

C(i, j) = min (pi + · · · + pj ) + C(i, k − 1) + C(k + 1, j)

i≤k≤j

To fill the table C we do so by increasing width w = j − i. Finally we

output the entry C(1, n). There are O(n2 ) entries in the table and each entry
takes O(n) time to fill, hence the total running time is O(n3 ).
The pseudocode for filling the table is on the following page.

8
Algorithm 6 BST(p1 , p2 , . . . , pn )
for i = 1 to n do
C(i, i) = pi
end for
for i = 1 to n do
for j = 1 to i − 1 do
C(i, j) = 0
end for
end for
for w = 1 to n − 1 do
for i = 1 to n − w do
j =i+w
C(i, j) = ∞
for k = i to j do
cur = (pi + · · · + pj ) + C(i, k − 1) + C(k + 1, j)
if C(i, j) > cur then
C(i, j) = cur
end if
end for
end for
end for
return (C(1, n))

9
[DPV] Problem 6.26 – Alignment
Solution: This is similar to the Longest Common Subsequence (LCS) prob-
lem, not the Longest Common Substring from this homework, and also to
the Edit Distance problem that we did in class, just a bit more complicat-
ed. Let us use a similar way to what we did for edit distance to define the
subproblem. Let

P (i, j) = maximum score of an alignment of x1 x2 . . . xi with y1 y2 ...yj .

Now, we figure out the dependency relationship. What subproblems does

P (i, j) depend on? There are three cases:

• Match xi with yj , then P (i, j) = δ(xi , yj ) + P (i − 1, j − 1);

• Match xi with −, then P (i, j) = δ(xi , −) + P (i − 1, j);

• Match yj with −, then P (i, j) = δ(−, yj ) + P (i, j − 1).

The recurrence then is the best choice among those three cases:

P (i, j) = max{δ(xi , yj )+P (i−1, j−1), δ(xi , −)+P (i−1, j), δ(−, yj )+P (i, j−1)}.

For the base case, we have to be a bit careful, there is no problem with
assigning P (0, 0) = 0. But how about P (0, j) and P (i, 0)? Can they also
be zero? The answer is no, they should not even be the base case and
should follow the recurrence of assigning P (0, 1) = δ(−, y1 ) and generally
P (0, j) = P (0, j − 1) + δ(−, yj ).
The running time is O(nm).

10
Algorithm 7 Alignment(x1 , x2 , . . . , xn , y1 , y2 , . . . , ym )
P (0, 0) = 0.
for i = 1 to n do
P (i, 0) = P (i − 1, 0) + δ(xi , −).
end for
for j = 1 to m do
P (0, j) = P (0, j − 1) + δ(−, yj ).
end for
for i = 1 to n do
for j = 1 to m do
P (i, j) = max{δ(xi , yj ) + P (i − 1, j − 1), δ(xi , −) + P (i −
1, j), δ(−, yj ) + P (i, j − 1)}
end for
end for
return P (n, m)

11