剪绳子问题

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

首先是贪婪算法：贪婪算法可以是找到一个数学情景，可以证明在这种场景下，达到最优解。在剪绳子的过程中，尽量剪长度为3的绳子，如果剩下的绳子是4，可以不用剪。由于5< 23，可以看出，当n>=5, 3（n-3）> n ,
2*(n-2)>n，并且3*（n-3）> 2*(n-2) 可以看出,n>5的时候，尽量剪成2和3的，并且，剪成3的长度优于2。4 =2 *2所以，剪成4和2一样。

class Solution(object):
    def cuttingRope(self, n):
        a = 0
        if n == 2:
            return 1
        if n == 3:
            return 2
        if n == 4:
            return 4
        while n >= 5:
            n = n - 3
            a += 1
        if n == 1:
            return pow(3, a)
        if n == 2:
            return 2 * pow(3, a)
        if n == 3:
            return 3 * pow(3, a)
        if n == 4:
            return 4 * pow(3, a)

2.动态规划
采用自底向上的思想，相当于一根绳子肯定会剪成两根，然后剩下的两根绳子再依次去剪。如果从1开始依次计算出每种长度的绳子的最优解，那么，新的绳子的长度的计算就可以依赖于之前的绳子，只需要拆成两种长度的相乘即可，因为之前的绳子已经是最优解了。
注意是一定要剪一刀，所以1，2，3，4情况特殊，列出来，与后面如果剪到1，2，3，4的时候不一样，剪下去不是最优解。

class Solution(object):
    def cuttingRope(self, n):
        if n == 1:
            return False
        if n == 2:
            return 1
        if n == 3:
            return 2
        if n == 4:
            return 4
        a = []
        a.append(0)
        a.append(1)
        a.append(2)
        a.append(3)
        a.append(4)
        for i in range(5, n+1):
            max = 0
            for j in range(1, i//2+1):
                if a[j]*a[i-j] > max:
                   max = a[j]*a[i-j]
            a.append(max)
        return a[n]