面试题14-剪绳子

题目：

给你一根长度为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^2)时间和O(n)空间的动态规划的思路，接着用只需要O（1）时间和空间的贪婪算法来分析解决这个问题。

动态规划

首先定义函数f（n）为把长度为n的绳子剪成若干段后各段长度乘积的最大值。在剪第一刀的时候，我们有n-1中可能的选择，也就是剪出来的第一段绳子的可能长度分别为1,2，…，n-1。因此f(n)=max(f(i)×f(n-i))，其中0<i<n。
这是一个从上至下的递归公式。由于递归会有很多重复的子问题，从而有大量不必要的重复计算。一个更好的办法是按照从下而上的顺序计算，也就是说我们先得到f(2)，f(3)，再得到f(4)，f(5)，直到得到f(n)。
当绳子的长度为2时，只可能剪成长度都为1的两段，因此f(2)等于1。当绳子的长度为3时，可能把绳子剪成长度分别为1和2的两段或者长度都为1的三段，由于1×2>1×1×1，因此f(3)=2。

C++实现

#include<iostream>
#include<vector>
using namespace std;
class Solution14
{
public:
	int maxProductAfterCutting_Solution1(int length)
	{
		if (length <= 1)
			return 0;
		else if (length == 2)
			return 1;
		else if (length == 3)
			return 2;
		int *products = new int[length + 1];
		products[0] = 0;
		products[1] = 1;
		products[2] = 2;
		products[3] = 3;
		int max = 0;
		//从4开始剪绳子
		for (int i = 4; i <= length; ++i)
		{
			max = 0;
			// 求出所有可能的f(j)×f(i-j)，并比较得出它们的最大值
			for (int j = 1; j <= i / 2; ++j)
			{
				int product = products[j] * products[i - j];
				if (max < product)
					max = product;
				products[i] = max;
			}
		}
		max = products[length];
		delete[]products;
		return max;
	}
};
//测试用例
int main()
{	
	Solution14 s;
	s.maxProductAfterCutting_Solution1(10);
	system("pause");
	return 0;
}

贪婪算法

如果我们按照如下的策略来剪绳子，则得到的各段绳子的长度的乘积将最大：当n>=5时，我们尽可能多地剪长度为3的绳子；当剩下的绳子长度为4时，把绳子剪成两段长度为2的绳子。

C++ 实现

	//贪婪算法
	int maxProductAfterCutting_Solution2(int length)
	{
		if (length < 2)
			return 0;
		if (length == 2)
			return 1;
		if (length == 3)
			return 2;
		//尽可能多的剪去长度为3的绳子段
		int timesOf3 = length / 3;
		//当绳子最后剩下的长度为4的时候，不能再剪去长度为3的绳子段
		//此时更好的办法是把绳子剪成长度为2的两段，因为2×2>3×1
		if (length - timesOf3 * 3 == 1)
			timesOf3 -= 1;
		int timesOf2 = (length - timesOf3 * 3) / 2;
		return(int)(pow(3, timesOf3))*(int)(pow(2, timesOf2));
	}
};

class Solution:
    def cuttingRope(self, n: int) -> int:
        if n==2:
            return 1
        if n==3:
            return 2
        timeOf3=n//3
        if n-timeOf3*3==1:
            timeOf3-=1
        timeOf2=(n-timeOf3*3)//2        
        return pow(3,timeOf3)*pow(2,timeOf2)

1. 时间复杂度：O（1）
2. 空间复杂度：O（1）

剑指 Offer 14- II. 剪绳子 II

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

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

class Solution:
    def cuttingRope(self, n: int) -> int:
        if n==2:
            return 1
        if n==3:
            return 2
        p=int(1e9+7) // 需要强转为int类型，不然结果会错误
        timeOf3=n//3
        if n-timeOf3*3==1:
            timeOf3-=1
            
        timeOf2=(n-timeOf3*3)//2 
        return int((pow(3,timeOf3)*pow(2,timeOf2))%p)

1. 时间复杂度：O（1）
2. 空间复杂度：O（1）