Lecture 15-17 - Dynamic Programming

Question 1

Name three key differences between Greedy and Dynamic Programming paradigms

Answer 1

Greedy
o Build up a solution incrementally.
o Iteratively decompose and reduce the size of the problem.
o Top-down approach.

Dynamic programming:
o Solve all possible sub-problems.
o Assemble them to build up solutions to larger problems.
o Bottom-up approach.

Question 2

Define the optimal sub-structure mathematically

Answer 2

Let Sij = subset of activities in S that start after ai
finishes and finish before aj starts.
Sij
= {ak ∈ S :∀i, j fi ≤ sk < fk ≤ sj}
• Aij = optimal solution to Sij
• Aij = Aik U { ak } U Akj

Question 3

How many sub-problems, and choices to consider, are there in the activity selection problem before and after Greedy choice?

Answer 3

Before theorem
Pick the best m such that Aij = Aim U { am } U Amj
Subproblems: 2
Choices: j-i-1

After theorem:
Choose am∈Sij with the earliest finish time (greedy choice)
Sub-problems: 1
Choices to consider: 1

Question 4

Define the Greedy choice theorem:

Answer 4

Theorem:
Let Sij ≠ ∅, and let am be the activity in Sij with the
earliest finish time: fm = min{ fk : ak ∈Sij}. Then:
1. am is used in some maximum-size subset of
mutually compatible activities of Sij.
2. Sim = ∅, so that choosing am leaves Smj as the only
nonempty subproblem.

Question 5

What is the input and output in weighted interval scheduling?

Is the greedy choice always effective in this problem?

Answer 5

Input: Set S of n activities, a1, a2, …, an.
– si = start time of activity i.
– fi = finish time of activity i.
– wi = weight of activity i

• Output: find maximum weight subset of mutually compatible activities.

Greedy choice isn’t always effective.

Question 6

Define Binary choice mathematically in terms of Opt(j) and p(j).

OPT(j) = value of the optimal solution to the problem
p(j) = largest index i < j such that activity/job i is
compatible with activity/job j.

Answer 6

Opt(j) =
0 if j = 0
max {wj + OPT(p(j)), OPT(j-1)} otherwise

Question 7

Define memoization.

Answer 7

Memoization: Cache results of each subproblem; lookup as needed.

for j = 1 to n
M[j] ← empty.
M[0] ← 0.

M-Compute-Opt(j)
if M[j] is empty
M[j] ← max(v[j]+M-Compute-Opt(p[j]),
M-Compute-Opt(j–1)).
return M[j].

Question 8

Prove that the memoized version of Binary choice takes O(nlogn) time.

Answer 8

Sort by finish time: O(nlogn)
Computing p(): O(nlogn) via sorting by start time

M-Compute-opt(j): O(n)
each invocation takes O(1) time and either:
1. returns existing M[j]
2. fills in one new entry M[j] and makes two recursive calls (at most 2n recursive calls)

Remark: O(n) if jobs are presorted by start and finish times.

Question 9

What’s the main idea of dynamic programming (in words)? How is this used in the Bottom-up algorithm?

Answer 9

Solve the sub-problems in an order that makes sure when you need an answer, it’s already been computed.

When we compute M[j], we only need values M[k] for k < j

BOTTOM-UP (n;s1,…,sn;f1,…,fn;v1,…,vn)
Sort jobs by finish time so that f1≤f2≤…≤fn.
Compute p(1), p(2), …, p(n).
M[0]←0
for j = 1 TO n
M[j] ← max { vj + M[p(j)], M[j–1] }

Question 10

How many recursive calls are there in the Find-Solution algorithm?

Answer 10

of recursive calls ≤ n ⇒ O(n).

Question 11

Do you remember how the reconstruction works (table example Lec 15)

Answer 11

Yes

Question 12

Define the shortest path u to v in terms of weight w().

Answer 12

w (p) = min {w(p) : u -> v} if path exists

inf otherwise

Question 13

What type of queues does Dijkstra’s algorithm use?

Are negative-weight edges allowed?

What type of keys does each node hold?

Is it dp or greedy choice?

Why is re-insertion in queue not a good idea to deal with negative weight edges? Why is adding a constant also not a good idea? give an example.

Answer 13

priority queue.

No negative weighted edges.

Keys are shortest-path weights (d[v])

Greedy.

Reinsertion -> exponential running time
Constant -> doesn’t always work, see lect 16

Question 14

How is the Bellman-Ford algorithm different than Djikstra’s?

Answer 14

it allows negative-weight edges.

Question 15

How does Bellman-Ford detect negative weight cycles?

Answer 15

If Bellman-Ford has not converged after V(G) - 1
iterations, then there cannot be a shortest path tree,
so there must be a negative weight cycle.

Returns TRUE if no negative-weight cycles
reachable from s, FALSE otherwise.

Question 16

What is the time complexity of Bellman-Ford? is it larger than djisktra’s?

Answer 16

O(VE)

Yes, because we relax much more often than in djikstra’s.

Question 17

Express bellman ford in terms of dynamic programming where d(i, j) = cost of the shortest path from s to i that is at most j hops.

Answer 17

d(i,j) = 
0     if (i = s) and (j = 0)
inf   if (i =/= s) and (j = 0)
min({d(k, j–1) + w(k, i): i E Adj(k)} or {d(i, j–1)})   if j > 0

Question 18

Why do loop V(G) - 1 times in bellman ford?

Answer 18

Explore all potential paths with all potential lengths.

Question 19

Is any greed algorithm optimal for the knapsack problem?

Answer 19

no, none of them are.

Question 20

What variable did we introduce in the knapsack problem to make it work?

Answer 20

The weight limited value, that is updated every time an item is selected.

Question 21

Define the knapsack problem mathematically using OPT(i,w).

Answer 21

OPT(i,w) =
0 if i = 0
OPT (i-1, w) if wi > w
max { OPT(i-1, w), vi + OPT (i-1, w - wi) } otherwise

Question 22

What’s the time complexity of the knapsack problem with dp?

Answer 22

OMEGA(n * W).

for each n, we iterate through w=1 to W.

Question 23

Do you remember how to do the bellman ford table?

Answer 23

Yes, lec 16 p 27.
Rows = iterations
Columns = node weights
every iteration, we relax all edges and enter the shortest path cost in cell.

Question 24

Do you remember how to do the knapsack problem table?

Answer 24

Yes, lec 16, p42.
Rows = bag with increasing items
Column = weight limit 1 -> W

Question 25

Define Pairwise Sequence alignment.

Answer 25

Let a=a1…am and b=b1…bn be two sequences over an alphabet Σ (i.e. a, b ∈Σ*). A pairwise alignment is a mapping f of the letters of a to b, such that if f(ai,bj) and f(ak,bl) then i

Question 26

In pairwise sequence alignment, define:
Match
Substitution
Insertion
Deletion

Answer 26

Match: letters are identical
Substitution: letters are different
Insertion: a letter of b is mapped to the empty character
Deletion: a letter of a is mapped to the empty character

Question 27

Let a=a1…am and b=b1…bn be two sequences over an alphabet Σ.
What are the three possibilities for counting alignment of:
(a1 … am)
(b1 … bn)

How can we rewrite this in terms of c(m,n)?

Answer 27

1. (a1 … am-1) (am)
   (b1 … bn ) ( _ )
2. (a1 … am-1) (am)
   (b1 … bn-1 ) (bn)

(a1 … am ) ( _ )
(b1 … bn-1 ) (bn)

c(m,n) = c(m-1,n) + c(m-1,n-1) + c(m,n-1)

Question 28

Given c(m,n) = c(m-1,n) + c(m-1,n-1) + c(m,n-1) and initialization c(0,n)=c(m,0)=c(0,0)=1, what’s the recursive evaluation value of c(2,2)

Answer 28

13

Question 29

Give a dp algorithm to compute all indices of c(m,n) = c(m-1,n) + c(m-1,n-1) + c(m,n-1).

What’s the complexity of this approach?

Answer 29

for i=0 to m do{
for j=0 to n do
c(i,j) = c(i-1,j)+c(i-1,j-1)+c(i,j-1)
}

Question 30

What are the three remarks we learned about the knapsack problem?

Answer 30

1. Pseudo-polynomial in input size
2. Decision version of knapsack problem is NP-Complete.
3. There exists a poly-time algorithm that produces a feasible solution that has value within 1% of optimum.

Question 31

Define Levenshtein distance.
Calculate it for the following:
ABB_CEE
_BBCCDE

Answer 31

The Levenshtein Distance between two words/sequences is the
minimal number of substitutions, insertions and deletions to transform one into the other

1 deletion + 1 insertion + 1 substitution ⟹ d=3

Question 32

Define Edit Cost and Edit Distance.

What is the application of these?

Answer 32

Edit Cost
Let δ(x,y) be a cost function for each edit operation (match,
substitution, insertion, deletion). The edit cost of two
words/sequences is the sum of the cost of each edit operation used transform one into the other.

Edit Distance)
The edit distance between two words/sequences is the minimal cost to transform one string into another. Generalization of the
Levenshtein distance.

Applications: Maximize the edit cost if higher values represent a similarity, minimize if you use an edit distance.

Question 33

Calculate the edit distance of
ABB_CEE
_BBCCDE
for d(x,y) = 0 if x = y, 1 otherwise

Do it again for
1 if x = y
-1 if x =/= y and x =/= _ or y =/= 0
-2 if x = _ or y = _

Answer 33

4 match+1 deletion+1 insertion+1 substitution
⟹ d = 4 * (0) + 1 * (+1) + 1 * (+1) + 1 * (+1) = 3

4 match+1 deletion+1 insertion+1 substitution
⟹ s = 4 * (1) + 1 * (-2) + 1 * (-2) + 1 * (-1) = -1

Question 34

What assumptions are we holding for Edit distance to be a metric?

Answer 34

• Every edit operation has positive cost
• for every operation, there is an inverse operation
with equal cost

Question 35

Prove the following:

“A sub-alignment of an optimal alignment w.r.t. the edit cost/distance is also optimal”

Answer 35

Proof: cut-and-paste argument & contradiction
• Let A be an optimal alignment
• Let A = A1A2A3 be a decomposition of A such that A2 is not optimal.
• Let A’2 be an optimal alignment of the substrings in A2
• Substitute A2 by A’2 to build a new alignment A’
• δ(A’) = δ(A1A’2A3) = δ(A1)+δ(A’2)+δ(A3) < δ(A1)+δ(A2)+δ(A3) = δ(A1A2A3) = δ(A)
• contradiction with A optimal

Question 36

What are the three cases for the Problem Structure of the following:
d(i,j) = minimal cost of aligning prefix strings a1…ai and b1…bj.

Answer 36

Case 1 (ai matches bj)
cost of matching ai with bj + min cost of aligning a1…ai-1 and b1…bj-1.
d (i,j) = delta(i,j) + d(i-1, j-1)

Case 2a (deletion of ai)
cost of deletion of ai + min cost of aligning a1…ai-1 and b1…bj.
d (i,_) = delta(i,_) + d(i-1, j)

Case 2b (insertion of bj)
cost of insertion of bj + min cost of aligning a1…ai and b1…b-1j.
d (_,j) = delta(_,j) + d(i, j-1)

Question 37

Define the Recursion solution to string alignment mathematically in terms of d(i,j)

Answer 37

d(i,j) = 
j * delta (_, *) if i = 0
i * delta (*, _) if j = 0
min of:
d (i,j) = delta(i,j) + d(i-1, j-1)
d (i,_) = delta(i,_) + d(i-1, j)
 (_,j) = delta(_,j) + d(i, j-1)
otherwise

Question 38

What’s the strategy to solve the string alignment problem using dp?

What does a table representing this look like?

What’s the name of the algorithm that solves this?

Answer 38

You only need to know the solutions of smaller (sub-)
alignments to compute a new one. Fill the dynamic array
following this partial order.
We define a partial order on the (sub-)alignments Amn such that
Amn <= Am’n’ if m<=m’ and n<=n’.

See slide 20 lec 17 for this table.

Needleman-Wunch Algorithm
for i=0 to m do
.......d(i,0)=i*δ(-,-)
for j=0 to n do
.......d(0,j)=j*δ(-,-)
for i=1 to m do
.......for j=1 to n do
..............d(i,j) = min(d(i-1,j)+δ(ai,-),
..............d(i-1,j-1)+δ(ai,bj),
..............d(i,j-1)+δ(-,bj))
return d(m,n)

Question 39

Apply the Needleman-Wunch algorithm on 
a = ATTG
b = CT
if delta(x,y) = 0 if x = y, 1 otherwise.

Show the corresponding table and final edit cost.

How do we backtrack?

Answer 39

d - A T T G
.- 0 1 2 3 4
C 1 .1 2 3 4
T 2 2 1 2 3

Backtracking
• Each move is associated to one edit operation
• Vertical = insertion
• Diagonal = match/substitution
• Horizontal = deletion
• We use one of these 3 move to fill a cell of the array
• From the bottom-right corner (i.e. d(m,n)), find the move that has been used to determine the value of this cell.
• Apply this principle recursively.

Question 40

Prove the following theorem:
The dynamic programming algorithm computes the edit distance (and optimal alignment) of two strings of length m and n in Omega(mn) time and Omega(mn) space.

Answer 40

Proof:
• Algorithm computes edits distance.
• Can trace back to extract an optimal alignment

Question 41

Can we avoid using quadratic space to compute Needleman-Wunch?
What do we sacrifice in order to do this?

Answer 41

Easy to compute optimal value in Omega(mn) time and Omega(m+n)
space.
• Compute OPT(i,⦁) from OPT(i-1,⦁).
• But, no longer easy to recover optimal alignment itself, only value.