剑指offer面试题14：剪绳子（Java 实现）

题目：给你一根长度为 n 的绳子，请把绳子剪成 m 段 (m 和 n 都是整数，n > 1并且m > 1)每段绳子的长度记为 k[0],k[1],…,k[m].请问 k[0]k[1]…*k[m] 可能的最大乘积是多少？例如，当绳子的长度为8时，我们把它剪成长度分别为2,3,3的三段，此时得到的最大乘积是18.

方法一：动态规划。时间复杂度为 O（n²），空间复杂度为 O（n）

可以看出这是一个递归问题，但是由于递归会产生很多重复的子问题，会导致很多不必要的重复计算。所以我们可以采用自下而上的计算方式，采用额外的存储空间，记录子问题的解，后续就可以直接使用，提高时间效率。

递归转动态规划实际上就是用牺牲空间换时间效率的一种做法。

public class test_fourteen {

	//动态规划
	public int maxProductAfterCutting(int len){
		
		if(len < 2)return 0;
		if(len == 2)return 1;
		if(len == 3)return 2;
		
		//定义一个数组用来存储长度从0-len的最大结果,也就是子问题的最优解
		int[] result = new int[len+1];
		result[0] = 0;
		result[1] = 1;
		result[2] = 2;
		result[3] = 3;
		
		int max = 0;
		for(int i=4; i<len+1; i++){               //自下而上计算
			
			for(int j=1; j <= i/2; j++){             //找出每一段长度的最优解
				int tempresult = result[j]*result[i-j];
				if(max<tempresult){
                    max = tempresult;
                }
                result[i] = max;
			}
		}
		max = result[len];
		return max;
	}
}

方法二：贪婪算法。时间复杂度为 O（1），空间复杂度为 O（1）。

当 n>=5 时，尽可能多地剪长度为3的绳子；当剩下的绳子长度为4是，吧绳子剪成两段长度为2的绳子。（这种方法 需要证明）

//贪婪算法
	public int maxProductAfterCutting1(int len){
		
		if(len < 2)return 0;
		if(len == 2)return 1;
		if(len == 3)return 2;
		
		//尽可能多地去减去长度为3的绳子段
		int timeOfThree = len/3;
		//当最后如果绳子的长度只剩下4时，就不应该剪去长度为3的绳子段(2*2 > 1*3)
		if(len-timeOfThree*3 == 1)
			timeOfThree -=1;
		int timeOfTwo = (len-timeOfThree*3)/2;
		
		return (int)(Math.pow(3, timeOfThree)*Math.pow(2, timeOfTwo));
	}