【算法】－ 动态规划的编织艺术

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.