剑指offer_剪绳子

题目：

给定一根长度为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。

转成数学模型：

给定一个数n，求$n=a_1+a_2+\dots a_m(m>1)$，使得$s=a_1\cdot a_2\cdots a_m$最大化。

如果用暴力枚举的思路思考这个问题，会出现以下两个问题：

（1）绳子应该分几段，才能得到最优结果？

（2）假设已经确定要分m段，那么每段的长度又应该是多少？

递归法

基本思想

递归三部曲

（1）递归函数的设计和功能：back_track(n) 输入长度：n，输出分段后的最大乘积。

（2）递归终止的条件：如果$n\le 4$，显然back_track(n) =n ，

（3）下一步递归：对于长度n，我们需要减少递归参数n。

​ 如果第一段为1， 显然下一步递归为back_track(n-1),

​ 如果第一段为2， 则下一步递归为back_track(n-2)

​ 所以，最后一次可能的情况为最后一段为n-1, 下一步递归为back_track(1)，

​ 因此，每一步可能的结果为1 * back_track(n-1), 2 * back_track(n-2), …, (n-1) * back_track(1),在n-1种情况中取一个最大值即可。 这里我们不用关系back_track(n-1)等的值为多少，因为最终会递归到我们的终止条件，因此绝对是可以求出来。

python实现

class compute_max_s:
  def back_track(self,n):
    # 长度小于4时，不分长度是最大的
    if(n<=4):
      return n 
    res = 0
    for i in range(1,n):
      res = max(res,i*back_track(n-i))
    return res  
  def cutRope(self,number):
    if(number == 2):
      return 1
    if(number == 3):
      return 2
    return back_track(number)  

调用

obj = compute_max_s()  
obj.cutRope(8)
# 输出18

时间复杂度为$O(n!)$

空间复杂度为$O(n)$

根据方法一，假设求back_track(7)，如下图：

用f() 替代 back_track(),可知，红色的部分重复了。
因此，我们可以开一个数组，把计算过的结果存起来。

动态规划

将计算结果存到arr中。

def cutRope(number):
  if(number == 2):
    return 1
  if(number == 3):
    return 2
  arr = [-1]*(number+1) 
  for i in range(0,5):
    arr[i] = i   
  for i in range(5,number+1):
    for j in range(0,i):
      arr[i] = max(arr[i],j*arr[i-j]) 
  return arr[number]   

调用

cutRope(8)
# 输出18

时间复杂度：$O(n^2)$
空间复杂度：$O(n)$