《算法导论》第十五章动态规划提出了“钢条切割”问题并给了三种解决方法,其一为自顶向下递归实现,其二为带备忘录的自顶向下递归,其三为自底向上法。其中后两种为动态规划算法。
动态规划方法通常用来求解最优化问题,这些问题满足最优子结构特性:问题的最优解由相关子问题的最优解组合而成,而这些子问题可以独立求解。
通常由一下四步设计动态规划算法:
1、刻画一个最优解的结构特征。
2、递归地定义最优解的值。
3、计算最优解的值,通常采用自底向上的方法。
4、利用计算出的信息构造一个最优解。
问题描述:
某公司出售一段长度为i的钢条价格为pi,并给出了一个价格表:
长度i 1 2 3 4 5 6 7 8 9 10
价格pi 1 5 8 9 10 17 17 20 24 30
求最佳切割方式,使切割后的钢条价格最高。
解决方法:
一、自顶向下递归实现:
尝试将钢条分为两部分求解,左部为长度为i的一段(i从1到10取值,价格表最长为10),右部递归继续切割。此问题的解空间可以描述为一个树,根为n,第一层节点从n-1到0,对于节点n-1表示左部长度为1,右部长度为n-1,并继续向下切割。可以看到,n-1节点的子树必然包括n-2节点的所有情况,所以这种方法存在大量的重复计算问题,导致时间效率较低,复杂度为2^n。
二、带备忘录的自顶向下实现:
针对第一种方法,可以考虑将计算过的问题保存在一个表中,当下次要用到的时候可以查表获得。因此新建一个r[n+1]的表,令r[0]=0,r[1...n]=负无穷,每当我们求解出一个子问题的解时,就填入这个表,下次再次需要解决这个子问题时直接查表获取即可。
三、自底向上方法
我们也可以采取非递归的方法实现,方法二是将大问题分解,分解过程中产生子问题解填入表,而方法三是从0到n构建表,即先求解出子问题解,然后向上组合出最优解。
JAVA代码如下:
package DynamicProgramming;
/**
*
* @author joddiy
*
*/
public class Cut_Rot {
private static final int price[] = { 1, 5, 8, 9, 10, 17, 17, 20, 24, 30 };
// 自顶向下递归
// 复杂度2^n
public static int UpToBottomRecursion(int n) {
if (n == 0) {
return 0;
}
int q = Integer.MIN_VALUE;
for (int i = 0; i < price.length; i++) {
if (n >= i) {
int temp = price[i] + UpToBottomRecursion(n - i - 1);
if (q < temp) {
q = temp;
}
}
}
return q;
}
// 带备忘的自顶向下递归
// 复杂度n*n
public static int MemoizedUTBRecursion(int n) {
int r[] = new int[n + 1];
for (int i = 1; i <= n; i++)
r[i] = Integer.MIN_VALUE;
return MemoizedUTBRecursion_AUX(n, r);
}
private static int MemoizedUTBRecursion_AUX(int n, int r[]) {
int q;
if (r[n] >= 0)
return r[n];
if (n == 0)
q = 0;
else {
q = Integer.MIN_VALUE;
for (int i = 1; i <= price.length; i++) {
if (n >= i) {
int temp = price[i - 1]
+ MemoizedUTBRecursion_AUX(n - i, r);
if (q < temp) {
q = temp;
}
}
}
}
r[n] = q;
return q;
}
// 自底向上建表
// 复杂度n*n
public static int BottomUp(int n) {
int r[] = new int[n + 1];
int q = 0;
r[0] = 0;
for (int j = 1; j <= n; j++) {
for (int i = 1; i <= j && i <= price.length; i++) {
int temp = price[i - 1] + r[j - i];
q = q > temp ? q : temp;
}
r[j] = q;
}
return r[n];
}
public static void TopLevel(int i) {
int questionSize = 25;
int result = 0;
long begin = System.currentTimeMillis();
switch (i) {
case 1:
result = UpToBottomRecursion(questionSize);
break;
case 2:
result = MemoizedUTBRecursion(questionSize);
break;
case 3:
result = BottomUp(questionSize);
break;
}
long end = System.currentTimeMillis();
System.out.println(result + " " + (end - begin) + "ms");
}
public static void main(String args[]) {
TopLevel(3);
TopLevel(2);
TopLevel(1);
}
}
运行结果: