剑指 Offer 14- I. 剪绳子（5种方案）

https://leetcode-cn.com/problems/jian-sheng-zi-lcof/
给你一根长度为 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。
参考https://leetcode-cn.com/problems/jian-sheng-zi-lcof/solution/jian-zhi-offerer-shua-java-di-gui-bei-wa-1pax/ 添加数学解法
思路：

1. 暴力递归
   当前绳子长度为n，考虑分出的第一段长度为i，则整个绳子最大乘积情况分为两种
   a. 最大为i * f(n - i) 但是f(n-i)却是n-i没进行切分这种情况
   b. 最大为i * (n - i)
   因为长度分为（i，n-i）与长度分为（n-i，i）的乘积是一样的，所以分出第一段长度只需要考虑1— n/2即可, 超时

class Solution(object):
    def cuttingRope(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n == 1:
            return 1
        if n == 2:
            return 1
        if n == 3:
            return 2
        result = 0
        for i in range(1, n / 2 + 1):
            j = n - i
            value1 = i * self.cuttingRope(j)
            value2 = i * j
            result = max([result, value1, value2])
        return result

2. 暴力解法超时，研究其递归过程，计算f(4)时需要计算f(2)，计算f(5)时同样需要计算f(2)，为重复计算。因此，使用空间换取时间的方式，对已经计算过的n进行记录，节约耗时。但是还是超时

class Solution(object):
    def cuttingRope(self, n):
        """
        :type n: int
        :rtype: int
        """
        tmp = [0] * (n + 1)
        if n == 1:
            return 1
        if n == 2:
            return 1
        if n == 3:
            return 2
        result = 0
        for i in range(1, n / 2 + 1):
            j = n - i
            if tmp[j] != 0:
                value1 = i * tmp[j]    # 改动在这里
            else:
                value1 = i * self.cuttingRope(j)
            value2 = i * j
            result = max([result, value1, value2])
        return result

3. 递归超时，考虑使用动态规划

class Solution(object):
    def cuttingRope(self, n):
        """
        :type n: int
        :rtype: int
        """
        tmp = [0] * (n + 1)
        if n == 1:
            return 1
        if n == 2:
            return 1
        if n == 3:
            return 2
        tmp[0] = 1
        tmp[1] = 1
        tmp[2] = 1
        tmp[3] = 2
        for i in range(1, n + 1):
            for j in range(1, i):
                tmp[i] = max([tmp[i], j * (i - j), j * tmp[i-j]])
        return tmp[-1]

4. 数学解法
思路：借助一个数学理论，和一定，差小积大。即总和一定情况下，value分布越均匀，则其乘积最大。
所以，如果要切分成m份，则应先给每段均匀分配n/m长度，之后再将n%m长度依次加在刚刚分好的各段上，够加几个加几个，则为当前乘积最大的分配方式。

class Solution(object):
    def cuttingRope(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n == 2:
            return 1
        result = 1
        for m in range(2, n):   # 分为n段每段是1，只有在2这种没有其余分配方式的情况下才会是最优的，但是因为2直接return了，因此不需要考虑分为n段的情况，判断到n-1即可
            tmp = 1
            v = n / m     # 第一次给每段分配的长度
            r = n % m     # 剩余长度
            for i in range(0, r):   # 剩余长度分配到的段
                tmp *= (v+1)
            for i in range(r, m):  # 剩余长度未分配到的段
                tmp *= v
            result = max(tmp, result)
        return result

5. 升级版数学规律
分出尽量多的3就是最优分配方案（不要问我为什么，就知道有这个理论，没仔细看）尽量多的3且不要有1，所以最后当大于4的时候，结束循环

class Solution(object):
    def cuttingRope(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n == 2:
            return 1
        if n == 3:
            return 2
        result = 1
        while n > 4:
            result *= 3
            n -= 3
        result = result * n
        return result