剑指 Offer 14- I. 剪绳子

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

思路一：动态规划

我们想要求长度为n的绳子剪掉后的最大乘积，可以从前面比n小的绳子转移而来；
用一个长度为n+1的dp数组记录从0到n长度的绳子剪掉后的最大乘积，也就是dp[i]表示长度为i的绳子剪成m段后的最大乘积；
我们先把绳子剪掉第一段（长度为j）；
剪了第一段后，剩下(i - j)长度可以剪也可以不剪。如果不剪的话长度乘积即为j * (i - j)；如果剪的话长度乘积即为j * dp[i - j]；
第一段长度j可以取的区间为[1,Math.ceil(i/2)]，对所有j不同的情况取最大值，因此最终dp[i]的转移方程为
dp[i] = max(dp[i], j * (i - j), j * dp[i - j])；
最后返回dp[n]即可。

var cuttingRope = function(n) {
    var dp = new Array(n + 1).fill(1);
    for (var i = 3; i <= n; i++){
        for (var j = 1; j < i; j++){
            //分两种情况：1.后面不再剪了，则值为j*(i-j);2.后面继续剪，值为j*dp[i-j](动态规划)
            dp[i] = Math.max(dp[i], j*(i-j), j*dp[i-j]);
        }
    }
    return dp[n];
};

思路二：贪心算法

前面提到：8 拆分为 3+3+2，此时乘积是最大的。然后就推测出来一个整数，要拆成多个 2 和 3 的和，保证乘积最大。原理很容易理解，因为 2 和 3 可以合成任何数字，例如5=2+3，但是5 < 23；例如6=3+3，但是6<33。所以根据贪心算法，就尽量将原数拆成更多的 3，然后再拆成更多的 2，保证拆出来的整数的乘积结果最大。

但上面的解法还有不足。如果整数 n 的形式是 3k+1，例如 7。按照上面规则，会拆分成“3 + 3 + 1”。但是在乘法操作中，1 是没作用的。此时，应该将 1 和 3 变成 4，也就是“3 + 3 + 1”变成“3 + 4”。此时乘积最大。

综上所述，算法的整体思路是：

n 除 3 的结果为 a，余数是 b

当 b 为 0，直接将 a 个 3 相乘

当 b 为 1，将（a-1）个 3 相乘，再乘以 4

当 b 为 2，将 a 个 3 相乘，再乘以 2

空间复杂度是 O(1)，时间复杂度是 O(1)。

var cuttingRope = function(n) {
    if (n <= 3) return n-1;

    var m = Math.floor(n / 3);
    var q = n % 3;
    if (q === 0) return Math.pow(3, m);
    if (q === 1) return Math.pow(3, m-1)*4;
    if (q === 2) return Math.pow(3, m)*2;
};

额外要求：答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

var cuttingRope = function(n) {
    if(n < 4) return n - 1;

    let res = 1;
    while(n > 4) {
        res = res * 3 % 1000000007;
        n -= 3;
    }
    return res * n % 1000000007;
};