数学方式解决

在做这题之前我们先来看这样一个问题,一个整数先把他分成两部分,x+y=n(假设x>=y并且x-y<=1,也就是说x和y非常接近)那么乘积是x*y。然后我们再把这两部分的差放大(x+1)+(y-1)=n(假设x>=y);他们的乘积是(x+1)*(y-1)=x*y-(x-y)-1,很明显是小于x*y的,所以我们得出结论,如果把整数n分为两部分,那么这两部分的值相差越小乘积越大。

同理还可以证明如果分成3部分,4部分……也是相差越小乘积会越大。

图片

根据上面的证明,如果我们把长度为n的绳子分为x段,则每段只有在长度相等的时候乘积最大,那么每段的长度是n/x。所以他们的乘积是(n/x)^x。我们来对这个函数求导

图片说明

通过对函数求导我们发现,当x=n/e的时候,也就是每段绳子的长度是n/x=n/(n/e)=e的时候乘积最大。我们知道e=2.718281828459。而题中我们的绳子剪的长度都是整数,所以不可能取e,我们只能取接近e的值,也就是3的时候乘积最大。

但也有例外,当n<=4的时候会有特殊情况,因为2*2>1*3。明白了这点代码就容易多了,如果n大于4,我们不停的把绳子减去3,来看下代码

    public int cutRope(int target) {
        if (target == 2 || target == 3)
            return target - 1;
        int res = 1;
        while (target > 4) {
            //如果target大于4,我们不停的让他减去3
            target = target - 3;
            //计算每段的乘积
            res = res * 3;
        }
        return target * res;
    }

时间复杂度:O(n),因为每次减去3,需要大约运行n/3次,所以时间复杂度是O(n)
空间复杂度:O(1),使用一个常量res即可

看一下运行结果

图片说明

或者如果不想使用循环,我们还可以使用公式

    public int cutRope(int target) {
        if (target == 2 || target == 3)
            return target - 1;
        else if (target % 3 == 0) {
            //如果target是3的倍数,绳子全部剪为3
            return (int) Math.pow(3, target / 3);
        } else if (target % 3 == 1) {
            //如果target对3求余等于1,我们剪出一个长度为4的,其他长度都是3
            return 4 * (int) Math.pow(3, (target - 4) / 3);
        } else {
            //如果target对3求余等于2,我们剪出一个长度为2的,其他长度都是3
            return 2 * (int) Math.pow(3, target / 3);
        }
    }

时间复杂度:O(1)
空间复杂度:O(1)


动态规划解决

定义一个数组dp,其中dp[i]表示的是长度为i的绳子能得到的最大乘积。我们先把长度为i的绳子拆成两部分,一部分是j,另一部分是i-j,那么会有下面4种情况


1,j和i-j都不能再拆了

  • dp[i]=j*(i-j);

2,j能拆,i-j不能拆

  • dp[i]=dp[j]*(i-j);

3,j不能拆,i-j能拆

  • dp[i]=j*dp[i-j];

4,j和i-j都能拆

  • dp[i]=dp[j]*dp[i-j];

我们取上面4种情况的最大值即可。我们把它整理一下,得到递推公式如下

dp[i] = max(dp[i], (max(j, dp[j])) * (max(i - j, dp[i - j])));

比如我们想计算长度为9的绳子,画个图来看一下
图片说明

计算长度为9的绳子之前,我们必须要先计算长度为8的绳子。对于长度为9的绳子我们可以先分为两部分,每一部分都取最大值,然后相乘。

最后再来看下代码

    public int cutRope(int target) {
        int[] dp = new int[target + 1];
        dp[1] = 1;
        for (int i = 2; i <= target; i++) {
            for (int j = 1; j < i; j++) {
                dp[i] = Math.max(dp[i], (Math.max(j, dp[j])) * (Math.max(i - j, dp[i - j])));
            }
        }
        return dp[target];
    }

时间复杂度:O(n^2)
空间复杂度:O(n),需要数组dp的大小

看一下运行结果

图片说明


截止到目前我在公众号“数据结构和算法”中已经写了500多道算法题,其中部分已经整理成了pdf文档,目前总共有1000多页(并且还会不断的增加),大家可以免费下载
下载链接https://pan.baidu.com/s/1hjwK0ZeRxYGB8lIkbKuQgQ
提取码:6666

如果觉得有用就给个赞吧,还可以关注我的《牛客博客》查看更多的详细题解