【牛客剑指offer刷题】：Python：70.剪绳子

描述

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

输入描述：

输入一个数n，意义见题面。（2 <= n <= 60）

返回值描述：

输出答案。

示例1

输入：8

返回值：18

解析

这是一篇针对初学者的题解，从暴力递归到动态规划一步步讲解。
知识点：递归，动态规划
难度：二星

题解

进入此题的讲解之前，先提出一个问题：什么样的题适合用动态规划？

针对本题来说，假如我们用暴力枚举的思路去思考，会出现以下一些问题：

• 这段绳子到底应该分几段，才能得到最优的结果？

• 假设我已经知道了要分m段（假设m已知），那么每段的长度又应该是多少呢？

可能你的问题不止上面2个。但是，仅仅是上面两个问题，已经让我感觉要分好多种情况，然后选出一个最优的。

当然，普通的for循环枚举所有情况是有难度的，但是幸运的是，我们可以用递归回溯。
所以，方法一如下：

方法一：暴力递归

暴力递归就要想到递归三部曲：

递归函数的设计和功能：back_track(n); 含义是：求长度为n的数，最后分段后的最大乘积，这里我们不需要关心分成多少段

递归函数的终止条件: 如果n <= 4, 显然back_track(n) = n，初始条件也就是我们不用计算就能得到的。

下一步递归：对于长度n，我们需要减少递归参数n，如果第一段为1， 显然下一步递归为back_track(n-1),如果第一段为2， 则下一步递归为back_track(n-2)…因为要至少分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)等的值为多少，因为最终会递归到我们的终止条件，因此绝对是可以求出来。

于是，有了上面三部曲，递归代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def cutRope(self, number):
        # write code here
        if number == 2:
            return 1
        elif number == 3:
            return 2
        return self.back_track(number)
    
    def back_track(self,number):
        if number <= 4:
            return number
        res = 0
        for i in range(1, number):
            res = max(res, i*self.back_track(number-i))
        return res

时间复杂度：O(n!)
空间复杂度：O(n), 最多分n段，每段长度为1， 所以递归深度为n

方法二：记忆化递归

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

我用f() 替代 back_track(),可知，红色的部分重复了。

因此，我们可以开一个数组，把计算过的结果存起来。

步骤如下：

初始化一个大小为 n+1 的数组，初始值为 -1 ， 也可以-2， 反正是不可能得到的值

在方法一的代码上，记录一下，详细代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def cutRope(self, number):
        # write code here
        if number == 2:
            return 1
        elif number == 3:
            return 2
        # 添加部分
        self.stack = [-1 for _ in range(number+1)]
        return self.back_track(number)
    
    def back_track(self,number):
        if number <= 4:
            return number
        
        # 在方法一的基础上添加
        if self.stack[number] != -1:
            return self.stack[number]
        
        res = 0
        for i in range(1, number):
            res = max(res, i*self.back_track(number-i))
        # 添加部分
        self.stack[number] = res
        return self.stack[number]

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

方法三：动态规划

有的书上认为方法二是一种递归版本的动态规划。
所以，我们可以将方法二修改为迭代版本的动态规划。

代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def cutRope(self, number):
        # write code here
        if number == 2:
            return 1
        elif number == 3:
            return 2
        
        stack = [-1 for _ in range(number+1)]
        for i in range(4):
            stack[i] = i+1
        for i in range(5, number+1):
            for j in range(1, i):
                stack[i] = max(stack[i], j*stack[i-j])
        return stack[number-1]

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

总的来说，方法一是基础。方法二，方法三都是在方法一的基础上修改的。

Q:接下来，我们就可以开篇的问题了，什么样的题适合用动态规划？
A：一般，动态规划有以下几种分类：

• 最值型动态规划，比如求最大，最小值是多少
• 计数型动态规划，比如换硬币，有多少种换法
• 坐标型动态规划，比如在m*n矩阵求最值型，计数型，一般是二维矩阵
• 区间型动态规划，比如在区间中求最值

其实，根据此题的启发，我们可以换种想法，就是什么样的题适合用暴力递归？

• 显然就是，可能的情况很多，需要枚举所有种情况。只不过动态规划，只记录子结构中最优的解。