題目：給你一根長度為n的繩子，請把繩子剪成m段（m、n都是整數，n>1并且m>1）,每段繩子的長度記為k[0]，k[1]，...，k[m]。請問
k[0]*k[1]*...*k[m]可能的最大乘積是多少？例如，當繩子的長度是8時，我們把它剪成長度分別為2、3、3的3段，此時得到的最大乘積是18。
動態規劃的概念
如果面試題是求一個問題的最優解（通常是求最大值或者最小值），而且該問題能夠分解成若干個子問題，并且子問題之間還有重疊的更小的子問題，就可以考慮用動態規劃來解決這個問題。
我們在應用動態規劃之前要分析能否把大問題分解成小問題，分解后的小問題也存在最優解。如果把小問題的最優解組合起來能夠得到整個問題的最優解，那么我們可以應用動態規劃解決這個問題。
在應用動態規劃解決問題的時候，我們總是從解決最小問題開始，并把已經解決的子問題的最優解存儲下來，并把子問題的最優解組合起來逐步解決大的問題。
應用動態規劃的時候，我們事先是不知道那種方法是最優的解法，只好把所有的可能都嘗試一遍。
解題思路：首先定義函數f(n)為把長度為n的繩子剪成若干段后各段長度乘積的最大值。在剪第一刀的時候，我們有n-1中選擇，也就是剪出來的第一段繩子的可能長度分別為1,2,3...,n-1。因此f(n) =max(f(i) * f(n-i))，其中0<i<n。
這里注意：f(n) = max(f(i) * f(n-i)) ，fn是所有可能的f(i) * f(n-i)的最大值，其中0<i<n。
這是一個從上至下的遞歸公式。由于遞歸會有很多重復的子問題，從而有大量不必要的重復計算。一個更好的辦法是按照從下到上的順序計算，也就是說我們先得到，
再得到
，
，直到得到
。
/**
* 動態規劃
*
* @param length 繩子的長度
* @return
*/
public static int maxProduceAfterCutting(int length) {
//異常情況
if (length < 2) {
return 0;
}
//繩子剪成m段，m>1 ,所以我們得剪成 1 * 1
if (length == 2) {
return 1;
}
//長度為3，只能剪成 1*2 最長的一段
if (length == 3) {
return 2;
}
//上面分別返回了長度小于等于3時候的最優解，下面是計算長度大于3時候的情況
//注釋1處，定義一個數組，用來保存計算出來的子問題的最優解
int[] products = new int[length + 1];
products[0] = 0;
products[1] = 1;
//注釋2處，
products[2] = 2;
//注釋3處，
products[3] = 3;
int result = 0;
//開始計算
for (int i = 4; i <= length; i++) {
int max = 0;
//注釋4處，直接從j=1開始，不需要從0開始。
for (int j = 1; j <= i / 2; j++) {
int product = products[j] * products[i - j];
if (max < product) {
max = product;
}
}
products[i] = max;
}
result = products[length];
return result;
}
注釋1處，定義一個數組，用來保存計算出來的子問題的最優解。products[i]表示長度為i的繩子剪成若干段之后隔斷成都的乘積的最大值，即。
注釋2處，為什么這里products[2]等于2？例如當繩子長度為3的時候，我們剪成兩段，其中一段為2，一段為1。這樣長度為2的那段最大值就是2，而不是1，因為這一段我們不需要再剪了。
注釋3處，初始化的時候為什么products[3]=3？因為當length<=3的時候，我們直接返回了結果。如果整個繩子的長度為3，我們必須把繩子剪開，因為題目要求m>1，其中一段為2，另一段為1，這樣結果就是2。當length>=4的時候，我們可以把繩子剪成兩段，其中一段為3,另一段為１，這樣長度為3的那一段的最大值就是3而不是2，因為這一段我們不需要再剪了。當然長度為4的最大值是剪成2和2的組合，我們已經存儲了2的長度。
注釋4處，直接從j=1開始，不需要從0開始。
貪婪算法
貪婪算法和動態規劃不一樣。當我們應用貪婪算法解決問題的時候，每一步都可以做出一個貪婪的選擇，基于這個選擇，我們確定能夠得到最優解。貪婪算法需要用數學的方式證明每一步的貪婪選擇是正確的。
貪婪算法
- 當 n>=5 時，盡可能多地剪長度為 3 的繩子
- 當剩下的繩子長度為 4 時，就把繩子剪成兩段長度為 2 的繩子。
證明：書上的證明。。。
- 當 n>=5 時，可以證明
，并且
。也就是說，當繩子剩下長度大于或者等于 5 的時候，可以把它剪成長度為 3 或者 2 的繩子段。
- 當 n>=5 時，
，因此，應該盡可能多地剪長度為 3 的繩子段。
- 當 n=4 時，剪成兩根長度為 2 的繩子，其實沒必要剪，只是題目的要求是至少要剪一刀。
/**
*
* @param length 繩子的長度
* @return
*/
public static int maxProduceAfterCuttingGreedy(int length) {
if (length < 2) {
return 0;
}
if (length == 2) {
return 1;
}
if (length == 3) {
return 2;
}
//盡可能多的減去長度為3的繩子段，這個需要去證明，長度為3的段數越多乘積越大
int timesOf3 = length / 3;
//注釋1處
if (length - timesOf3 * 3 == 1) {
timesOf3 -= 1;
}
int timeOf2 = (length - timesOf3 * 3) / 2;
return (int) Math.pow(3, timesOf3) * (int) Math.pow(2, timeOf2);
}
注釋1處，當繩子最后剩下的長度為4的時候，不能再減去長度為3的繩子段，此時更好的方法是把繩子減去長度為e的兩段，因為2*2>3*1。
比如繩子長度為13:
- 盡可能減長度為3的繩子，可以剪4段長度為3的繩子，還剩一根長度為1的繩子，最終乘積是：
3*3*3*3*1 =81。 - 盡可能減長度為3的繩子，可以剪3段長度為3的繩子，當繩子最后剩下的長度為4的時候，不能再減去長度為3的繩子段，最終乘積是：
3*3*3*4 = 27 * 4 108。
參考鏈接：
