14.剪绳子

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

示例 1：

输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1
示例 2:

输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36
提示：

2 <= n <= 58

思路：

1. 数学天才，直接推导出，绳子要切成每段3米，尽可能多的情况下，乘积最大。 推导过程就不贴了。 大家记住结论就好。
   下面展示一些 内联代码片。
   时间复杂度：o(1)
   空间复杂度: o(1)

// A code block
def cuttingRope1_0(self, n): # 数学推导
        if n<=3:
            return n-1
        cut = n//3 - 1
        res = n - (cut+1)*3
        if res == 0: 
            return 3 ** (cut+1)
        elif res == 1:
            return 3 ** cut * 4
        elif res == 2:
            return 3 **(cut+1) * 2

2. DP，这个就比较万能了，像上面那种 换个条件可能就不适用了
   思路：dp[i]就是用来存储i米长的绳子可得到的最大乘积。那怎么求呢，

• 首先全部初始化为0，因为绳子大于1米，所以从dp[2]开始考虑，2米最优解是1米，没什么好说的。
• 接着开始填2以后的乘积。那就是 range（3，n+1）了，而j则是代表，i米长的绳子，从中切j米出来，遍历j ，0~i-1米，看从j切多少米比较合适。

盗张图，这样比较好理解。dp是一种自下而上的思想，步步为营，首先从dp[2]开始，因为dp[2]是最优的，算dp[3]，从3米中切出j米来遍历所有切法。然而切分的方法有两种，第一种：切j米后，剩下的（3-j）不动 和j 直接乘，第二种：剩下的（3-j）选择最优的dp[i-j]。 因为3-j比i小，为3，2，1，所以dp[i-j]一定是之前已经算过的最优解。
那有人就问了，为啥不直接是dp[i]=max(dp[i],dp[i-j]*j)呢？
那dp[3]举例，
j = 0，=max(0,max(0,0))
j = 1, =max(0,max(2,1))
j = 2, =max(2,max(2,0))
j = 0，=max(0,0)
j = 1, =max(0,1)
j = 2, =max(1,0)
这样就发现问题了，由于绳子必须要切大于1段，所以dp[i-j]实际上是i-j米切>=2段时的最优解，并没有考虑将i-j作为一个整体和j相乘。所以还是要加上 [i-j]*j。
时间复杂度：o(n2) 循环嵌套
空间复杂度：o(n) 一个大小为n的列表

// An highlighted block
def cuttingRope1_1(self,n): #np的动态规划
        dp = [0 for _ in range(n+1)]
        dp[2] = 1
        for i in range(3,len(dp)):
            for j in range(i):
                dp[i] = max(dp[i],max(j*(i-j),dp[i-j]*j))
        return dp[n]

还有第二小题 return dp[n]%max_threshold就行了。

动态规划法