14-dynamic-programming-work-methods.pptx

COMPSCI 311: Introduction to
Algorithms
Lecture 14: Dynamic Programming
Ghazaleh Parvini
University of Massachusetts
Amherst

Algorithm Design Techniques
► Greedy
► Divide and Conquer
► Dynamic
Programming
► Network Flows

Learning Goals
Greed
y
Divide
and
Conquer
Dynamic
Programmi
ng
Formulate problem
Design algorithm
Prove correctness
Analyze running
time Specific
algorithms
Dijkstra
, MST
Bellman-
Ford

Weighted Interval Scheduling
► TV scheduling problem: n shows, can only watch one at
a time. New twist: show j has value vj . Want a set of
shows S with no overlap and highest total value.
► Example on board
► Greedy?

Weighted Interval Scheduling
► TV scheduling problem: n shows, can only watch one at
a time. New twist: show j has value vj . Want a set of
shows S with no overlap and highest total value.
► Example on board
► Greedy? No longer optimal.

Problem Formulation
► Show (job) j has value vj , start time sj , finish time fj
► Assume shows sorted by finishing time f1 ≤ f2 ≤ . . .
≤ fn
► Shows i and j are compatible if they don’t overlap
► Goal: subset of non-overlapping jobs with
maximum value

Dynamic Programming Recipe
► Step 1: Devise simple recursive algorithm for value
of optimal solution
► Flavor: make “first choice”, then recursively
solve remaining part of the problem.
(Problem: solve redundant subproblems →
exponential time)

of optimal solution
exponential time)
► Step 2: Write recurrence for optimal value

of optimal solution
exponential time)
► Step 3: Design bottom-up iterative algorithm

of optimal solution
exponential time)
► Step 3: Design bottom-up iterative algorithm
► Epilogue: Recover optimal solution

Step 1: Recursive Algorithm
► Observation: Let O be the optimal solution. Either
n ∈ O or n ∈/ O. In either case, we can reduce the
problem to a smaller instance of the same problem.

► Recursive algorithm to compute value of optimal
subset of first
j shows
Compute-Value(j)

subset of first
j shows
Compute-Value(j)
Base case: if j = 0 return 0

subset of first
j shows
Compute-Value(j)
Case 1: j ∈ O
Let i < j be highest-numbered show compatible
with j
val1 = vj + Compute-Value(i)

subset of first
j shows
Compute-Value(j)
Case 1: j ∈ O
Let i < j be highest-numbered show compatible
with j
Case 2: j ∈/ O
val2 = Compute-Value(j − 1)

Clicker
Compute-
Value(j) if j = 0
return 0
Let i < j be
highest-
numbered
show
compatible
with j
val2 = Compute-Value(j −
1) return max(val1, val2)
The running time of this
recursive solution is
A. O(n log n)

Running
Time?
► Recursion
tree

Running
Time?
► Recursion tree
► ≈ 2n subproblems ⇒ exponential
time

Running Time?
► Recursion tree
► ≈ 2n subproblems ⇒ exponential time
► Only n unique subproblems. Save work by
ordering computation to solve each problem
once.

Step 2: Recurrence
A recurrence expresses the optimal value for a problem of
size j in terms of the optimal value of subproblems of size i
< j.
`
x
C
a
˛
s
¸
e
1
OPT(0) = 0
OPT(j) = max{vj + OPT(pj ),
`
x
C
a
˛
s
¸
e
2
OPT(j − 1)}
► OPT(j): value of optimal solution on first j shows
► pj : highest-numbered show i < j that is compatible
with j

Recursive Algorithm vs. Recurrence
► Compute-Value(j)
If j = 0 return 0
val1 = vj + Compute-Value(pj
) val2 = Compute-Value(j −

If j = 0 return 0
► Recurrence
OPT(j) = max{vj + OPT(pj ), OPT(j − 1)}
OPT(0) = 0

If j = 0 return 0
► Recurrence
OPT(0) = 0
► Direct correspondence between the algorithm
and recurrence

If j = 0 return 0
► Recurrence
OPT(0) = 0
► Direct correspondence between the algorithm
and recurrence
► Tip: start by writing the recursive algorithm and
translating it to a recurrence (replace method name by
“OPT”). After some practice, skip straight to the
recurrence

Step 3: Iterative “Bottom-Up”
Algorithm
Idea: compute the optimal value of every unique
subproblem in order from smallest (base case) to largest
(original problem). Use recurrence for each subproblem.
WeightedIS

Algorithm
WeightedIS
Initialize array M of size n to hold optimal values

Algorithm
WeightedIS
M [0] = 0 ▷ Value of
empty set

Algorithm
WeightedIS
M [0] = 0 ▷ Value of
empty set
for j = 1 to n do

Algorithm
WeightedIS
▷ Value of empty
set
M [0] = 0
for j = 1 to n do
M [j] = max(vj + M [pj ], M [j −
1])

Algorithm
WeightedIS
▷ Value of empty
set
M [0] = 0
for j = 1 to n do
M [j] = max(vj + M [pj ], M [j −
1])
► Example

Step 3: Observations
WeightedIS
Initialize array M of size n to hold optimal
values ▷ Value of empty
set
M [0] = 0
for j = 1 to n do
M [j] = max(vj + M [pj ], M [j −
1])
► Iterative algorithm is a direct “wrapping” of
recurrence in appropriate for loop.
► Pay attention to dependence on previously-
computed entries of
M to know in what order to iterate through array.
► Running time?

Step 3: Observations
WeightedIS
Initialize array M of size n to hold optimal
values ▷ Value of empty
set
M [0] = 0
for j = 1 to n do
M [j] = max(vj + M [pj ], M [j −
1])
► Iterative algorithm is a direct “wrapping” of
recurrence in appropriate for loop.
► Pay attention to dependence on previously-
computed entries of
M to know in what order to iterate through array.
► Running time? O(n)

Memoization
Intermediate approach: keep recursive function
structure, but store value in array on first
computation, and reuse it

Memoization
Initialize array M of size n to empty, M[0] = 0

Memoization
function Mfun(j)

Memoization
function Mfun(j)
if M[j] = empty then

Memoization
function Mfun(j)
M[j] = max(vj + Mfun(pj ), Mfun(j − 1))

Memoization
function Mfun(j)
M[j] = max(vj + Mfun(pj ), Mfun(j − 1))
return M[j]
► Can help if we have recursive structure but
unsure of iteration order, or as intermediate step in
converting to iteration

Clicker
The asymptotic running time of the memoized algorithm is
A. the same as the initial recursive solution.
B. between the initial recursive solution and the iterative
version.
C. the same as the iterative version.

Epilogue: Recovering the Solution
(1)
Idea: modify the algorithm to save best choice for each
subproblem WeigthedIS
Initialize array M [0 . . . n] to hold optimal
values Initialize array choose[1 . . . n] to
hold choices M [0] = 0
for j = 1 to n do
M [j] = max(vj + M [pj ], M [j − 1])
Set choose[j] = 1 if first value is bigger,
and 0 otherwise

Epilogue: Recovering the Solution (2)
Then trace back from end and "execute" the
choices

(2)
choices Use algorithm above to fill in M and
choose arrays

(2)
choose arrays O = {}

(2)
j = n

(2)
j = n
while j > 0 do

(2)
j = n
while j > 0 do
if choose(j) == 1 then

(2)
j = n
while j > 0 do
O = O ∪ {j}

(2)
j = n
while j > 0 do
O = O ∪ {j}
j = pj

(2)
j = n
while j > 0 do
O = O ∪ {j}
j = pj
else

(2)
j = n
while j > 0 do
O = O ∪ {j}
j = pj
else
j = j − 1

(2)
j = n
while j > 0 do
O = O ∪ {j}
j = pj
else
j = j − 1
► Tip: first write algorithm to compute optimal
value, then modify to compute actual solution

Revie
w
► Recursive algorithm → recurrence → iterative
algorithm

Review
algorithm
► Three ways of expressing value of optimal
solutions of subproblems

Review
algorithm
► Compute-Value(j). Recursive algorithm:
arguments identify subproblems.

Review
algorithm
► OPT(j). Used in recurrence; matches recursive
algorithm.

Review
algorithm
► OPT(j). Used in recurrence; matches recursive
algorithm.
► M [j]. Array to hold optimal values, filled in
during iterative algorithm.

Key Step: Identify Subproblems
► Finding solution means: make “first choice”, then
recursively solve a smaller instance of same problem.

► First example: Weighted Interval Scheduling
► Binary first choice: j ∈ O or j ∈/ O?

► First example: Weighted Interval Scheduling
► Binary first choice: j ∈ O or j ∈/ O?
► Next example: rod cutting
► First choice has n options

Rod
Cutting
► Input: steel rod of length n, can be cut into
integer lengths, get price p(i) for piece of length i
► Goal: subdivide to maximize total value
► Example / problem formulation on board

First decision?
Choose length i of first piece, then recurse on
smaller rod
max (
p1 + Rod_Cut(n-1),
p2 + Rod_Cut(n-2),
.
.
.
P(n-1)+ Rod_Cut(1),
P(n) )

Step 1: Recursive
Algorithm
CutRod(j)

Step 1: Recursive
Algorithm
CutRod(j)
if j = 0 then return
0

Step 1: Recursive
Algorithm
CutRod(j)
0
v = 0

Step 1: Recursive
Algorithm
CutRod(j)
0
v = 0
for i = 1 to j do

CutRod(j)
if j = 0 then return 0
v = 0
for i = 1 to j do
v = max
!
v, p[i] + CutRod(j − i)
"

Step 1: Recursive
Algorithm
CutRod(j)
v = 0
for i = 1 to j do
v = max
!
"
return v
CutRod(0)
CutRod(1)
CutRod(2)
..
.
.
CutRod(n

CutRod(j)
v = 0
for i = 1 to j do
v = max
!
"
return v
► Running time for CutRod(n)?

CutRod(j)
v = 0
for i = 1 to j do
v = max
!
"
return v
► Running time for CutRod(n)?
Θ(2n)

Step 2:
Recurrence
1≤i≤j
OPT(j) = max
)
pi + OPT(j − i)
}

Step 2:
Recurrence
OPT(j) = max
)
pi + OPT(j − i)
}
1≤i≤j
OPT(0) = 0

From Recurrence to
Algorithm
1≤i≤j
OPT(j) = max
)
pi + OPT(j − i)
}

From Recurrence to Algorithm
OPT(j) = max
)
pi + OPT(j − i)
}
1≤i≤j
OPT(0) = 0
What size memoization array M ? What order to fill?
The recurrence provides all of the information needed
to design an iterative algorithm.

OPT(j) = max
)
pi + OPT(j − i)
}
1≤i≤j
OPT(0) = 0
► Cutrod(·), OPT (·), and M [·] have same argument:

OPT(j) = max
)
pi + OPT(j − i)
}
1≤i≤j
OPT(0) = 0
index j of unique subproblems

OPT(j) = max
)
pi + OPT(j − i)
}
1≤i≤j
OPT(0) = 0
► Range of values of j determines size of M .

OPT(j) = max
)
pi + OPT(j − i)
}
1≤i≤j
OPT(0) = 0
► Range of values of j determines size of M . M [0..n]

OPT(j) = max
)
pi + OPT(j − i)
}
1≤i≤j
OPT(0) = 0
► Fill M so RHS values are computed before LHS.

OPT(j) = max
)
pi + OPT(j − i)
}
1≤i≤j
OPT(0) = 0
► Fill M so RHS values are computed before LHS. Fill
from 0 to
n

Step 3: Iterative
Algorithm
CutRod-Iterative

Step 3: Iterative
Algorithm
CutRod-Iterative
Initialize array M
[0..n]

Step 3: Iterative
Algorithm
CutRod-Iterative
Initialize array M
[0..n] Set M [0] = 0

Step 3: Iterative Algorithm
CutRod-Iterative
Initialize array M
[0..n]
Set M [0] = 0
for j = 1 to n do

CutRod-Iterative
Initialize array M
[0..n]
Set M [0] = 0
for j = 1 to n do
v = 0

CutRod-Iterative
Initialize array M
[0..n]
Set M [0] = 0
for j = 1 to n do
v = 0
for i = 1 to j do

CutRod-Iterative
Initialize array M
[0..n]
Set M [0] = 0
for j = 1 to n do
v = 0
for i = 1 to j do
v = max
!
v, p[i]
+ M [j − i]
"

CutRod-Iterative
Initialize array M
[0..n]
Set M [0] = 0
for j = 1 to n do
v = 0
for i = 1 to j do
v = max
!
v, p[i]
+ M [j − i]
"
Set M [j] = v

CutRod-Iterative
Initialize array M
[0..n]
Set M [0] = 0
for j = 1 to n do
v = 0
for i = 1 to j do
v = max
!
v, p[i]
+ M [j − i]
"
Set M [j] = v
► Note: body of for loop identical to recursive
algorithm, directly implements recurrence

CutRod-Iterative
Initialize array M
[0..n]
Set M [0] = 0
for j = 1 to n do
v = 0
for i = 1 to j do
v = max
!
v, p[i]
+ M [j − i]
"
Set M [j] = v
► Running time?

CutRod-Iterative
Initialize array M
[0..n] Set M [0] = 0
for j = 1 to n
do v = 0
for i = 1 to j do
v = max
!
v,
p[i] + M
[j − i]
"
Set M [j] = v
► Running time? Θ(n2)

Epilogue: Recover Optimal Solution
Idea: Modify algorithm to record choices that lead to
optimal value for each subproblem, then trace back from
the end and “execute” the choices, starting with the largest
problem.

problem.
Step 1: Run previous algorithm to fill in M array, but with
the following modification: let first-cut[j] be the index i
that leads to the largest value when computing M [j].

problem.
Step 2: Trace back from end and execute choices.

problem.
Step 2: Trace back from end and execute
choices. cuts = {}

problem.
choices. cuts = {}
j = n
▷ Remaining length

problem.
choices. cuts = {}
j = n
▷ Remaining length
while j > 0 do

problem.
choices. cuts = {} ▷ Remaining
length
j = n
while j > 0 do
j = j − first-
cut[j]

problem.
choices. cuts = {} ▷ Remaining
length
j = n
while j > 0 do
j = j − first-cut[j]
cuts = cuts ∪ {first-
cut[j]}

14-dynamic-programming-work-methods.pptx

More Related Content

Similar to 14-dynamic-programming-work-methods.pptx (20)

Recently uploaded (20)

14-dynamic-programming-work-methods.pptx