# Lecture 15-17 - Dynamic Programming Flashcards

1
Q

Name three key differences between Greedy and Dynamic Programming paradigms

A

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.

2
Q

Define the optimal sub-structure mathematically

A
```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```
3
Q

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

A

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

4
Q

Define the Greedy choice theorem:

A

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.

5
Q

What is the input and output in weighted interval scheduling?

Is the greedy choice always effective in this problem?

A

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.

6
Q

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.

A

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

7
Q

Define memoization.

A

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].```
8
Q

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

A
```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.

9
Q

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

A

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] }

10
Q

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

A

of recursive calls ≤ n ⇒ O(n).

11
Q

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

A

Yes

12
Q

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

A

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

inf otherwise

13
Q

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.

A

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

14
Q

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

A

it allows negative-weight edges.

15
Q

How does Bellman-Ford detect negative weight cycles?

A

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.

16
Q

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

A

O(VE)

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

17
Q

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.

A
```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```
18
Q

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

A

Explore all potential paths with all potential lengths.

19
Q

Is any greed algorithm optimal for the knapsack problem?

A

no, none of them are.

20
Q

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

A

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

21
Q

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

A

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

22
Q

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

A

OMEGA(n * W).

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

23
Q

Do you remember how to do the bellman ford table?

A

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

24
Q

Do you remember how to do the knapsack problem table?

A

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

25
Q

Define Pairwise Sequence alignment.

A

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

26
Q
```In pairwise sequence alignment, define:
Match
Substitution
Insertion
Deletion```
A

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

27
Q

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)?

A
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)

28
Q

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)

A

13

29
Q

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?

A

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)
}

30
Q

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

A
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.
31
Q

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

A

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

32
Q

Define Edit Cost and Edit Distance.

What is the application of these?

A

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.

33
Q

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 = _

A

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

34
Q

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

A

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

35
Q

Prove the following:

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

A

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

36
Q

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.

A
```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)```
37
Q

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

A
```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```
38
Q

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?

A

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)```
39
Q
```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?

A

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.

40
Q

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.

A

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

41
Q

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

A

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.