用动态规划算法求解钢条切割问题

        分治方法将问题划分为互不相交的子问题，递归地求解子问题，再将它们组合起来，求出原问题的解。与之相反，动态规划应用于子问题重叠的情况，即不同的子问题具有公共的子子问题。

        钢条切割问题：出售一段长度为i英寸的钢条的价格为Pi：

长度i    1    2    3    4     5      6      7      8      9     10

价格pi  1    5    8    9    10    17    17    20    24    30

可以先将长度为n的钢条分割成n1长度段和n2长度段，分别对n1和n2求最优解，这样划分的左右两边都要进行最优解求取。较为复杂。

       另一种方法是 利用递归求解方法：将钢条从左边切割下长度为i的一段，只对右边剩下的长度n-1的一段继续进行切割，对左边的一段则不再进行切割。Rn = max(Pi + Rn-i) = max(P1+Rn-1,  P2+Rn-2, ......, Pn+R0)。

对于子问题最优解的求法可以自顶向下求解，也可以自底向上求解。为了避免多次求解公共的子问题，这里利用了辅助空间来记录已经取得公共子问题，当使用时直接在内存调用即可。

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

int max(int a, int b)
{
    if(a > b)
        return a;
    else
        return b;
}

/*没有辅助空间的传统求解方法*/ 
int Cut_rod(int P[], int n)
{
    int q = -1;
    int i = 0;
    
    if(n == 0)
        return 0;
    
    for(i=1; i <= n; i++)
    {
        q = max(q, P[i] + Cut_rod(P, n-i));
    }
    
    return q;
}


/*使用辅助空间的自顶向下的求解方法*/ 
int Cut_rod_aux(int P[], int n, int *r);

int Cut_rod1(int P[], int n)
{
    int i = 0;
    int result = 0;
    int *r = (int *)malloc( sizeof(int)*(n+1));
    if( r == NULL )
        return -1;
        
    for(i=0; i <= n; i++)
    {
        r[i] = -1;
    }
    
    result = Cut_rod_aux(P, n, r);
    
    free(r);
    
    return result;
}

int Cut_rod_aux(int P[], int n, int *r)
{
    int q = -1;
    int i = 0;
    if( r[n] >= 0)
    {
        return r[n];
    }
    
    if(n == 0)
        q = 0;
    else
    {
        q = -1;
        
        for(i = 1; i <= n; i++)
        {
            q = max(q, P[i] + Cut_rod_aux(P, n-i, r));
        }
    }
    r[n] = q;//记录子问题的最优解
    
    return q; 
}

/*使用辅助空间的自底向上的求解方法*/ 
int Cut_rod2(int P[], int n)
{
    int q = -1;
    int i = 0, j = 0;
    int result = 0;
    
    int *r = (int *)malloc( (n+1) * sizeof(int) );
    if( r == NULL )
        return -1;
    
    r[0] = 0;
        
    for(j = 1; j <= n; j++)
    {
        q = -1;
        for(i=1; i <= j; i++)
        {
            q = max(q, P[i] + r[j-i]);
        }
        r[j] = q;//记录子问题的最优解
    }
    
    result =  r[n];
    
    free(r);
    
    return result;
}


int main()
{
    int i = 0;
    int P[] = {0, 1, 5, 8, 9, 10, 17, 17, 20, 24, 30};
    int n = sizeof(P) / sizeof(P[0]) - 1;
    
    for(i=1; i <= n; i++)
    {
        int result = Cut_rod2(P, i);
        printf("result = %d\n", result); 
    }

    return 0;
}