Reference: Introduction to Algorithms
Dynamic Programming is used to solve optimization problem.
It firstly partition the problem into subproblems.
Then combine the solution of subproblems into the solution of the original problem.
It has 4 steps when solving problems.
step 1. Characterize the structure of Optimal Solution
step 2. Recursively define the value of Optimal Solution
step 3. Bottom-up or Top-down compute the value of Optimal Solution
step 4. Construct the Optimal Solution
Problem:
Given a rod of length n, and cut it into pieces, and sell them.
There's a price table for each length.
To find the maximum revenue after selling all the pieces.
Take n=4 as an example.
There are 2^(n-1) different ways to cut the rod.
Below is the price table.
step 1. Characterize the structure of Optimal Solution
Use k to denote the number of pieces,
Then we get the list of length for each piece.
Then we get the total revenue.
step 2. Recursively define the value of Optimal Solution
Our target is the r for length n.
To solve it with a simple mind,
We just consider cutting it into 2 pieces, with length of i and n-i, (i is 1...n-1).
And compare with no cut.
Then the revenue can be represented recursively.
step 3. DP (Bottom-up or Top-down) , Straightforward compute the value of Optimal Solution
Straightforward
Running time: 2^n
Inefficient because it computes the same subproblems repetly.
import math
class solution():
def straight(self,n,price):
if n==0:
return 0
<span style="color:#ff0000;">r=-1</span>
for i in range(1,n+1):
r=max(<span style="color:#ff0000;">r</span>,price[i]+self.straight(n-i,price))
return r
Using Dynamic Programming to solve subproblem only once.
By saving the result of subproblem in array or hash table.
Check if r(i) is already computed, just return it, otherwise compute it through the recursive formula.
Top-down
Difference is just 'save' and 'check'
import math
class solution():
def topdown(self,n,price):
if n==0:
return 0
r=[-1 for i in range(0,n+1)]
return self.topdownhelp(n,price,r)
def topdownhelp(self,n,price,r):
if r[n]>=0:
return r[n]
if n==0:
q=0
else:
q=-1
for i in range(0,n+1):
q=max(q,price[i]+self.topdownhelp(n-i,price,r))
r[n]=q
return q
Bottom-up
To solve the problem starting from solving smaller subproblem.
a problem of size i is “smaller” than a subproblem of size j if i < j
then solves subproblems of sizes j = 0...n
Difference is 'save' no 'check'
import math
class solution():
def bottomup(self,n,price):
if n==0:
return 0
r=[-1 for i in range(0,n+1)]
r[0]=0
for j in range(1,n+1):
q=-1
for i in range(1,j+1):
q=max(q,price[i]+r[j-i])
r[j]=q
return r[n]
step 4. Construct the Optimal Solution
Save s[j] to hold the optimal size i cut off of subproblem with length j.
import math
class solution():
def bottomup(self,n,price):
if n==0:
return 0
r=[-1 for i in range(0,n+1)]
s=[0 for i in range(0,n+1)]
r[0]=0
for j in range(1,n+1):
q=-1
for i in range(1,j+1):
if q<price[i]+r[j-i]:
q=price[i]+r[j-i]
s[j]=i
r[j]=q
return r and s
def printbottomup(self,n,price):
(r,s)=self.bottomup(n,price)
while n>0:
print s[n]
n=n-s[n]
Above function bottom up will return the following r and s.
Above function printbottomup will return 1,6 for n=7.