CSci 231 Homework 7 Solutions - Bowdoin College

CSci 231 Homework 7 Solutions ∗
Dynamic Programming and Greedy Algorithms
CLRS Chapter 15 and 16
Use a (single) separate sheet of paper for each problem. Be concise.
1. A game-board consists of a row of n fields, each consisting of two numbers. The first
number can be any positive integer, while the second is 1, 2, or 3. An example of a
board with n = 6 could be the following:
17 2 100 87 33 14
1 2 3 1 1 1
The object of the game is to jump from the first to the last field in the row. The top
number of a field is the cost of visiting that field. The bottom number is the maximal
number of fields one is allowed to jump to the right from the field. The cost of a game
is the sum of the costs of the visited fields.
Let the board be represented in a two-dimensional array B[n, 2]. The following recursive
procedure (when called with argument 1) computes the cost of the cheapest
game:
Cheap(i)
END Cheap
IF i>n THEN return 0
x=B[i,1]+Cheap(i+1)
y=B[i,1]+Cheap(i+2)
z=B[i,1]+Cheap(i+3)
IF B[i,2]=1 THEN return x
IF B[i,2]=2 THEN return min(x,y)
IF B[i,2]=3 THEN return min(x,y,z)
∗ Collaboration is allowed and encouraged, if it is constructive and helps you study better. Remember,
exams will be individual. List the names of the collaborators with the solutions.

(a) Analyze the asymptotic running time of the procedure.
Solution:
T (n) = T (n − 1) + T (n − 2) + T (n − 3) + Θ(1)
≥ 3 T (n − 3)
= 3 2 T (n − 6)
= . . .
= 3 k T (n − 3k)
≥ 3 n/3
= Ω(3 n/3 ).
(b) Describe and analyze a more efficient algorithm for finding the cheapest game.
Solution: We create a table T of size n in which to store our results of prior
runs. The modified algorithm would be as follows:
Cheap(i)
END Cheap
IF T[i] != ∅ THEN return T[i]
IF i>n THEN return 0
x=B[i,1]+Cheap(i+1)
y=B[i,1]+Cheap(i+2)
z=B[i,1]+Cheap(i+3)
IF B[i,2]=1 THEN T[i] = x
IF B[i,2]=2 THEN T[i] = min(x,y)
IF B[i,2]=3 THEN T[i] = min(x,y,z)
return T[i]
The cost of a recursive call is O(1) and we fill each entry in the table at most
once, so the running time is O(n).
2

2. In this problem we consider the 0-1 knapsack problem: Given n items, with item
i being worth v[i] dollars and having weight w[i] pounds, fill a knapsack of capacity m
pounds with the maximal possible value.
Example: Given a knapsack of capacity 50, the maximal value obtainable
with three items of value $60, $100, and $120 and weights 10, 20, and 30,
respectively, is $220.
$60
10
$100
20
Items in value
per pound
order
$120
30
30
20
= $220
Optimal solution
for knapsack of
size 50
20
10
= $160
Greedy solution
for knapsack of
size 50
The algorithm Knapsack(i,j) below returns the maximal value obtainable when filling
a knapsack of capacity j using items among items 1 through i (Knapsack(n,m)
solves our problem). The algorithm works by recursively computing the best solution
obtainable with the last item and the best solution obtainable without the last item,
and returning the best of them.
Knapsack(i,j)
IF w[i]

Solution:
(a) Following the hint, if w[i] = 1 then it is clear that T (n, m) > 2T (n − 1, m −
1) + 1. This recurrence, which runs for min(m, n) steps, gives that T (n, m) =
Ω(2 min(m,n) ).
(b) We create a table of size [n][m] in which to store our results of prior runs. The
modified algorithm would be as follows:
Knapsack(i,j)
END
IF table[i][j] != 0 THEN
RETURN table[i][j]
IF w[i]

3. Imagine now that the items in the problem above are such that you can take fractions
of items. With this modified condition, the problem is called the Fractional
Knapsack problem. Identify a greedy strategy to solve the problem. Prove that
this strategy correctly identifies an optimal solution for all possible inputs.
Analyse the running time of your algorithm and compare it with the 0-1 knapsack
problem running time.
Does it pay off being greedy (in this case)?
Solution: Let v[i] and w[i] denote the weight and value of item i, respectively.
Compute for each item the price per pound vp[i] = v[i]/w[i].
Sort the items in decreasing order of their vp[i]. For simplicity renumber the elements
so that the first item is the one with the largerst vp and so on.
The choice that the thief has to make is which item to include in the knapsack. Being
a thief it is very tempting to be greedy, and go for the big buck first. Here is the
algorithm:
FR-Knapsack(i, w)
//returns the maximum value obtainable when filling a
//knapsack of capacity $w$ with using items $i$ through $n$.
IF i > n RETURN 0
IF w[i] S, and
therefore we get a contradiction. Thus we have proven that the first item is always
part of an optimal solution.
The rest of the correctness proof follows by induction on i. The algorithm is trivially
true when i = n. Let S1n be the optimal solution FR-KNAPSACK(1, w) and let S2n
5

e the optimal solution for FR-KNAPSACK(2, w-w[1]). By induction hypothesis
we assume that S2n is computed correctly by FR-KNAPSACK(2, w-w[1]). We
know that the first item is part of S1n, and let the remaining part of S1n be called S ′ :
S1n = v[1] + S ′ . S ′ contains items 2 through n and therefore S ′ is at most the optimal
solution S2n: S ′ ≤ S2n.
Then S ′ = S2n, otherwise we could replace S ′ with S2n in S1n and get a solution
v[1] + S2n > v[1] + S ′ = S1n, contradiction. Thus v[1] + S2n is the optimal solution for
FR-KNAPSACK(1, w).
6

4. Suppose you are in charge of planning a party for Bowdoin College. The college has
a hierarchical structure, which forms a tree rooted at President Mills. On the very
last level are the faculty, grouped by department. (I have such a chart in my office, if
you need to be visual). Each faculty has “underneath” all students taking a class with
him/her that particular semester. Assume that every person is listed at the highest
possible position in the tree and there are no double affiliations (everybody has one
and only one supervisor in this hierarchy and no student is in more than one class).
You have access to a secret database which ranks each faculty/staff/student with a
conviviality rating (a real number, which can be negative if the person is really difficult
or boring). In order to make the party fun for everybody, President Mills does not
want both a faculty/staff/student and his or her immediate “supervisor” to attend.
You are given a tree that describes the strucure of Bowdoin College. Each node has
a (down) pointer to its left-most child, and a (right) pointer to its next sibling (if
unclear read Section 10.4 in CLR). Each node also holds a name and a conviviality
ranking. Describe an algorithm to make up a guest list that maximizes the sum of the
conviviality rankings of the guests. Analyze the running time of your algorithm.
Solution: Let x be a node in the tree.
Let PartyMix(x) return the optimal conviviality rating obtainable from the subtree
rooted at x.
We want to compute PartyMix(President Mills).
Here is the recursive formulation of PartyMix(x):
Let ch(x) be the list of children of x.
Let grc(x) be the list of grandchildren of x.
PartyMix(x) = 0 if x == NULL
PartyMix(x) = max {conv(x) +
y∈grc(x) P artyMix(y),
z∈ch(x) P artyMix(z)}
To make this approach efficient, we keep a table with T [x] storing the solution of
PartyMix(x). Initially all entries in the table are set to −∞.
Analysis: The table has n entries. Assume that these entries are computed in bottomup
order so that we can ignore the recursion costs. An entry x is computed in
O(|ch(x)|+|gr(x)|) time. Thus to compute all entries it takes
x |ch(x)|+|gr(x)| time.
A node can only be child to a single node, so it is counted only once in
x |ch(x)|.
Similarly a node can be grandchild to a single node, so it is counted only once in
x |gc(x)|. Thus
x |ch(x)| + |gr(x)| is O(n). Therefore the algorithm takes O(n)
time.
7