# 程序代写代做代考 algorithm Dynamic Programming

Dynamic Programming

Dynamic Programming

Dr Timothy Kimber

February 2018

Rod Cutting Problem

Back To Solving Problems

The Rod Cutting Problem

A business buys steel rods in a variety of lengths

They will cut the rods into smaller pieces to sell on

Each rod size has a different market value

What is the maximum revenue R(N) for a rod of length N?

Is p(3) + p(3) + p(3) + p(1) > p(4) + p(4) + p(2) ?

Algorithms (580) Dynamic Programming February 2018 2 / 21

Rod Cutting Problem

Instance of The Problem

If the selling prices for each size of rod up to 10 are

size 1 2 3 4 5 6 7 8 9 10

price 3 4 6 9 16 20 22 24 26 30

Then the answer for N = 10 is 32 (1× 6 + 4× 1, or 2× 5)

Algorithms (580) Dynamic Programming February 2018 3 / 21

Rod Cutting Problem

Rod Cutting

size 1 2 3 4 5 6 7 8 9 10

price 3 4 6 9 16 20 22 24 26 30

Question

Given an array of prices P = [P1, . . . ,Pk ] and an integer N between 1 and

k , how can R(N) be computed?

Algorithms (580) Dynamic Programming February 2018 4 / 21

Rod Cutting Problem Analysis

Design

size 1 2 3 4 5 6 7 8 9 10

price 3 4 6 9 16 20 22 24 26 30

Possible outline:

Choose some sizes s = 〈s1, . . . , sj〉 that sum to N

(Values can repeat in s)

Compute Rs = P[s1] + · · ·+ P[sj ]

For all possible s

Update current best R(N) as you go

Algorithms (580) Dynamic Programming February 2018 5 / 21

Rod Cutting Problem Analysis

Design

size 1 2 3 4 5 6 7 8 9 10

price 3 4 6 9 16 20 22 24 26 30

Question

How do you generate (only) sequences s that sum to N?

At this point it will be useful to think about reducing the problem to

solving one or more smaller subproblems.

Algorithms (580) Dynamic Programming February 2018 6 / 21

Rod Cutting Problem Analysis

Design

size 1 2 3 4 5 6 7 8 9 10

price 3 4 6 9 16 20 22 24 26 30

Choosing sizes:

Pick an s1

Then s is s1 followed by 〈s2, . . . 〉 that sum to N − s1

Can now see the structure of the problem:

For each possible s1

Find all solutions for N − s1, and combine with s1

Base case: only sequence that sums to 0 is 〈〉

Algorithms (580) Dynamic Programming February 2018 7 / 21

Rod Cutting Problem Analysis

Design

size 1 2 3 4 5 6 7 8 9 10

price 3 4 6 9 16 20 22 24 26 30

Re-evaluate overall design:

Pick an s1

Max revenue using s1 is P[s1] + R(N − s1)

R(N − s1) is overall solution for rod length (N − s1)

One option per value for s1

Algorithms (580) Dynamic Programming February 2018 8 / 21

Rod Cutting Simple Algorithm

A Simple Recursive Solution

SimpleRodCut(Input: N, P = [P1, . . . ,Pk ])

if N == 0

return 0

else

for i = 1 to N

choices[i] = P[i] + SimpleRodCut(N-i, P)

return max(choices)

choices collects total for each s1

max finds the maximum of the choices

How does this run?

Algorithms (580) Dynamic Programming February 2018 9 / 21

Rod Cutting Simple Algorithm

Simple Rod Cut — Reflection

WOW that was sloooooowww.

Question

Solving R(0) takes Θ(1) time. What about R(N)?

Algorithms (580) Dynamic Programming February 2018 10 / 21

Rod Cutting Time

Time for Simple Solution

The time taken by SimpleRodCut is

T (0) = Θ(1)

T (N) = 2T (N − 1) + Θ(1), for N > 0

or

T (N) = 2N−1T (0) + Θ(1)

so T (N) = Θ(2N).

The running time grows exponentially.

This is not a practical solution.

Algorithms (580) Dynamic Programming February 2018 11 / 21

Other Strategies Divide & Conquer

Divide & Conquer?

Can we divide the problem? (and conquer?)

size 1 2 3 4 5 6 7 8 9 10

price 3 4 6 9 16 20 22 24 26 30

Algorithms (580) Dynamic Programming February 2018 12 / 21

Other Strategies Dynamic Programming

New Strategy

What is there that we can take advantage of?

The subproblems overlap

Algorithms (580) Dynamic Programming February 2018 13 / 21

Other Strategies Dynamic Programming

Dynamic Programming

Dynamic Programming makes a space–time tradeoff

Do not want to recompute the answer to R(i) every time

Compute it once and save the answer in a table

Check the table before computing each subproblem

This is called memoisation (we are making a note for later)

MemoisedRodCut(Input: N, P = [P1, . . . ,Pk ])

for i = 0 to N

R[i] = 0

return MemoiseAux(N, P, R)

R is the table to be filled in

Algorithms (580) Dynamic Programming February 2018 14 / 21

Other Strategies Dynamic Programming

Memoisation

MemoiseAux(Input: N, P = [P1, . . . ,Pk ], R = [R0, . . . ,RN′ ])

if N == 0

return 0

if R[N] > 0

return R[N]

for i = 1 to N

choices[i] = P[i] + MemoiseAux(N-i, P, R)

R[N] = max(choices)

return R[N]

If R[N] was already computed (R[N] > 0) it is returned immediately

Otherwise we compute it, save it, and then return it

Also called Top Down (set out to solve the biggest problem)

Algorithms (580) Dynamic Programming February 2018 15 / 21

Other Strategies Dynamic Programming

The ‘Bottom Up’ Method

We know which problems depend on which others

so we can just complete the table in order

this will be more efficient than recursion

BottomUpRodCut(Input: N, P = [P1, . . . ,Pk ])

R[0] = 0

for i = 1 to N

choices = [0,…,0]

for j = 1 to i

choices[j] = P[j] + R[i-j]

R[i] = max(choices)

return R[N]

What is the running time?

Algorithms (580) Dynamic Programming February 2018 16 / 21

Dynamic Programming Properties

Dynamic Programming

Dynamic programming can be applied to a problem if

The problem has optimal substructure

The problem has overlapping subproblems

A problem has optimal substructure if

the problem can be decomposed into subproblems

an optimal solution uses optimal solutions to the subproblems

In rod cutting the optimal solution for N was one of

P[i ] + R[N − i ], where 1 ≤ i < N and each R[N − i ] was an optimal solution for N − i . Algorithms (580) Dynamic Programming February 2018 17 / 21 Dynamic Programming Optimal Substructure Optimal Substructure Problems may appear to have optimal substructure when they do not Problem (Unweighted Shortest Path) Input: graph G = (V ,E ). Input: vertices u, v ∈ V . Output: the simple path from u to v containing the fewest edges Problem (Unweighted Longest Path) Input: graph G = (V ,E ). Input: vertices u, v ∈ V . Output: the simple path from u to v containing the most edges Algorithms (580) Dynamic Programming February 2018 18 / 21 Dynamic Programming Optimal Substructure Optimal Substructure A shortest path is composed of optimal solutions to subproblems The shortest path from 1 to 2 (via x) is shortest path from 1 to x plus the shortest path from x to 2 Algorithms (580) Dynamic Programming February 2018 19 / 21 Dynamic Programming Optimal Substructure Optimal Substructure How about a longest path? Independent subproblem solutions do not make an optimal solution In an optimal solution the subproblems will interfere Algorithms (580) Dynamic Programming February 2018 20 / 21 Dynamic Programming Overlapping Problems Overlapping Subproblems The second property we need when applying dynamic programming is overlapping subproblems The same problems are generated over and over The subproblems must still be independent The set of all subproblems is the subproblem space The smaller the subproblem space the quicker the (dynamic) algorithm Algorithms (580) Dynamic Programming February 2018 21 / 21 Rod Cutting Problem Problem Analysis Simple Algorithm Time Other Strategies Divide & Conquer Dynamic Programming Dynamic Programming Properties Optimal Substructure Overlapping Problems