动态规划之钢条切割

    《算法导论》第十五章动态规划提出了“钢条切割”问题并给了三种解决方法，其一为自顶向下递归实现，其二为带备忘录的自顶向下递归，其三为自底向上法。其中后两种为动态规划算法。

    动态规划方法通常用来求解最优化问题，这些问题满足最优子结构特性：问题的最优解由相关子问题的最优解组合而成，而这些子问题可以独立求解。

    通常由一下四步设计动态规划算法：

    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);
	}
}

    运行结果：