15.Dynamic Programming(1)

DP is a kind of tabular method, like divide-and-conquer method, applying when subproblems overlap.(sharing subsubproblems).

A DP algorithm solves each subsubproblems only once and then saves its answer in a table.

A divide-and-conquer algorithm does more work than necessary. It repeatedly solves the subsubproblems.

15.1 Rod cutting problem

lenght i	1	2	3	4	5	6	7	8	9	10
price  pi	1	5	8	9	10	17	17	20	24	30

For the table above, the optimal solution is:

                                             

Suppose we divide a rod into n pieces, we should have n-1 cuts at the rod. There is 2^(n-1) different cut ways of length n.

Optimal revenue values of rod n,can be caculated by

                                                                                     

where .

We can view ,saying that the first piece has size of i = n, and the remainder has the size n-i=n-n=0 with corresponding revenue .

As the following arithmetics,we can rewrite the formula above as

                                   

Algorithms as follows:

1.naive recursive top-down implementation

#include <iostream>
 using namespace std;
 #include <ctime>
 //naive recursive method
 int RotCut(int* p, int n)
 {
     if (n==0)
     {
         return 0;
     }
     int i;
     int q = INT_MIN;
 
 
     // q=max(p[i]+r[n-i]), p为数组，从0开始
     for( i=1; i<=n; i++)
     {
         int k = p[i-1] + RotCut(p,n-i);
         if (q < k)
         {
             q = k;
         }        
     }
     return q;
 }
 int main()
 {
     // p[] = {1,5,8,9,10,17,17,20,24,30}
     int p[100] ={1,5,8,9,10,17,17,20,24};
     time_t tic = time(NULL);
     int k = RotCut(p,25);
     time_t toc = time(NULL);
     cout<<"optimal value:"<<k<<"  "<<"time: "<<(toc-tic)*1000<<"ms"<<endl;
     return 0;
 }

 

    The results run by this program is listed as follows:

n	4	8	20	25	30
optimal val	10	22	56	69	85
run time	0	0	0	1s	27s

    This recursive CUT_ROD is very inefficient, cause it calls itself over and over with the same parameter values, that is ,it solve the same subproblems repeatedly.For example, figure follows illustrates what happens when n is 4.The running time of CUT-ROD is exponential in n.

                                                      

 

2.DP for optimal rod cutting

       Using DP can convert CUT-ROD into an efficient algorithm, making

       DP solves each subproblems only once by using additional memory to improve efficiency.There are two equivalent ways to implement DP algorithm: (1)top-down with memoization and (2)bottom-up method.

(1) Top-down with memoization

Recursively anyway, but save the result of each subproblem ( n subproblems ) in an array  r[] initial with 0s or a hash table. The array is used for check wether a subproblem was solved, if the ith subproblem was solved, its value was stored in r[i] > 0.

#include <iostream>
using namespace std;
#include <ctime>
const int MAXiSIZE=2000;
//Top-down with memoization method
int MemoizedCutRodAux(int *p, int n, int *r)
{     //using an addition array r[] to store optimal subproblems value
    if ( r[n] >= 0)
        return r[n];
    int q,i,k;
    if ( n == 0)
    {
        q = 0;
    }
    else 
    {
        q = INT_MIN;// iter method
        for ( i=1; i<=n; i++)
        {
            k = p[i-1] + MemoizedCutRodAux(p,n-i,r);
            if ( q<k )
                q =k;                    
        }
    }
    r[n] = q;
    return q;    
}

int MemoizedCutRod(int *p, int n)
{
    int i;
    int r[MAXiSIZE];//auxiliary array initialized with minimum
    for ( i=0; i<=n; i++)
    {
        r[i] = INT_MIN;    
    }
    return MemoizedCutRodAux(p,n,r);
}
int main()
{
    // p[] = {1,5,8,9,10,17,17,20,24,30}
    int p[MAXISIZE] ={1,5,8,9,10,17,17,20,24};
    /*time_t tic = time(NULL);
    int k = RotCut(p,25);
    time_t toc = time(NULL);
    cout<<"optimal value:"<<k<<"  "<<"time: "<<(toc-tic)*1000<<"ms"<<endl;*/
    
    clock_t start = clock();
    int k = MemoizedCutRod(p,1000);
    clock_t end = clock();
    cout<<"optimal value:"<<k<<"  "<<"time: "<<double(end-start)/CLOCKS_PER_SEC<<"s"<<endl;
    //int k = BottomUpCutRod(p,40);
    //cout<<k<<endl;

    //SolutionOfCutRod(p,40);
    return 0;
}

 

n	4	20	30	1000	1999
optimal val	10	56	85	2832	INT_MAX
run time	0	0	0	0.015s	0.047s

(2)bottom-up method

  Not recursively, but iteratively.  Solve the subproblems by size and solve them in size order, smallest first.

#include <iostream>
using namespace std;
#include <ctime>
const int MAXiSIZE=2000;
int BottomUpCutRod(int *p, int n)
{
    int r[MAXiSIZE];//auxiliary array initialized with minimum
    r[0] = 0;
    
    int i,j,k;
    for ( j=1; j<=n; j++)
    {
        int q = INT_MIN;
        for ( i=1; i<=j; i++)
        {
            k = p[i-1] + r[j-i];
            if ( q < k )
                q = k;
            r[j] = q;
        }
    }
    return r[n];
}
int main()
{
    // p[] = {1,5,8,9,10,17,17,20,24,30}
    int p[MAXISIZE] ={1,5,8,9,10,17,17,20,24};

    clock_t start = clock();
    //int k = MemoizedCutRod(p,1999);
    int k = BottomUpCutRod(p,40);
    clock_t end = clock();
    cout<<"optimal value:"<<k<<"  "<<"time: "<<double(end-start)/CLOCKS_PER_SEC<<"s"<<endl;

    return 0;
}

 

n	4	20	30	1000	1999
optimal val	10	56	85	2832	INT_MAX
run time	0	0	0	0	0.016s

  

3.Solution

Easy part for this example, only need a list store every piece size.

#include <iostream>
using namespace std;
#include <ctime>
const int MAXiSIZE=2000;
int ExtendedBottomUpCutRod(int *p, int n, int* r, int *s)
{
    
    int i,j,k;
    for ( j=1; j<=n; j++)
    {
        int q = INT_MIN;
        for ( i=1; i<=j; i++)
        {
            k = p[i-1] + r[j-i];
            if ( q < k )
            {
                q = k;
                s[j] = i;// here is the add item
            }
            r[j] = q;
            
        }
    }
    return r[n];
    
}

int SolutionOfCutRod(int *p, int n)
{
    int s[MAXiSIZE],r[MAXiSIZE];
    r[0] = 0;

    ExtendedBottomUpCutRod(p,n,r,s);
    cout<<"value of solution: "<<r[n]<<endl<<"solution:";
    while ( n>0 )
    {
        cout<<s[n]<<" ";
        n = n - s[n];
    }
    cout<<endl;
    return r[n];

}

int main()
{
    // p[] = {1,5,8,9,10,17,17,20,24,30}
    int p[MAXISIZE] ={1,5,8,9,10,17,17,20,24};
    
    SolutionOfCutRod(p,40);
    return 0;
}