分治方法将问题划分为互不相交的子问题,递归地求解子问题,再将它们组合起来,求出原问题的解。与之相反,动态规划应用于子问题重叠的情况,即不同的子问题具有公共的子子问题。
钢条切割问题:出售一段长度为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;
}