剑指 Offer 14-I/14-II-剪绳子I/剪绳子IIc++

-----------------------------2020/12/22二刷--------------------------------
14-I

数学推导

class Solution {
public:
    int cuttingRope(int n) {
        if(n <= 3)
            return n-1;
        int q = n / 3;
        int r = n % 3;
        if(r == 0) return pow(3,q);
        if(r == 1) return pow(3,q-1)*4;
        return pow(3,q)*2;

    }
};

14-II

数学推导

class Solution {
public:
    int cuttingRope(int n) {
        if(n <= 3) return n - 1;
        int ans = 1;
        
        while(n > 4) {
            n-=3;
            ans*=3;
        }
        //最后一次进入循环之前有四种可能
        // 7 6 5 
        //ans * n 分别对应 *4 *3 *2都是正确的
        return ans * n; 
    }
};

之前欠的动态规划得还了

动态规划

由于动态规划没刷过就是菜啦 ，还是只能依靠别人dp思路。

1. dp数组的含义：长度为i的绳子切分成两段以上所得的最大乘积。

2. dp方程，对于长度为i的绳子，固定第一个数字j，将其拆分成 j 与 i - j,则有两种dp方案

   • 将 i 拆分成 j 和 i−j 的和，且 i−j 不再拆分成多个正整数，此时的乘积是 j×(i−j)；
   • 将 i 拆分成 j 和 i−j 的和，且 i−j 继续拆分成多个正整数，此时的乘积是 j×dp[i−j]。

又可以得知j的取值为[1 , (i + 1)/2 ]
所以可得dp方程
dp[i]= max(dp[i], max(j * (i - j), j * dp[i - j]));
3. 初始值，感觉用处不是很大， dp[0]和dp[1]不能通过方程得到，但dp[0]并不会被用到，dp[1]只要小于1都无所谓。
代码

class Solution {
public:
    int cuttingRope(int n) {
        vector<int> dp (n + 1, 1);
        for (int i = 2; i <= n; i++) {
            for (int j = 1; j <= (i + 1) / 2; j ++) {
                dp[i]= max(dp[i], max(j * (i - j), j * dp[i - j]));//max中的dp[i]是为了保存内循环中的最大值
            }
        }
        return dp[n];
    }
};

时间复杂度O(n^2)，空间复杂度O(n)
-----------------------------一刷--------------------------------
面向对象的考试怎么能那么离谱…挂科率40真的是他一手弄出来的

题目描述

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

解法一 数学推导

可以用数学的方法推断出每段拆成3的时候是最优解的。具体过程参考 来自大佬Krahets的解答

class Solution {
public:
    int cuttingRope(int n) {
        if(n<=3)  
            return n-1;
        int q=n/3,r=n%3;
        switch(r)
        {
            case 0: return pow(3,q);break;
            case 1:return pow(3,q-1)*4;break;
            case 2:return pow(3,q)*2;break;
            default: return -1;
        }
    }
};

n太小所以都是0ms

时间O(1)空间O(1)

解法二 贪心算法

如果已经能够通过数学方法得知每段为3的结论，本质上贪心算法和其做法一样，当剩余长度大于5时每段都切成3,当切到4时，4的最优解是2*2即不切
即
n小于4：返回n-1;
n等于4：返回4；
n大于4时：继续切割成长度为3的小段；

class Solution {
public:
    int cuttingRope(int n) {
        if(n<=3)  
        	return n-1;
        int ans=1;
        while(n>4)
        {
            n=n-3;           
            ans=ans*3;         
        }
        return ans*n;
    }
};

时间O(n),空间O(1)

解法三 动态规划

感觉动态规划还是不太懂，发现题解里面的动态规划思路都是一样的，应该有一定的规律。
这里用别人的代码。

放一篇文章防止自己不去看了 动态规划套路详解-米奇罗

题目描述

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

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

贪心算法和数学解答还是不受影响，而动态规划的最大值就出现了问题。
数学解答的变化就是pow函数这时候不能直接用了。
这时候就需要手动求幂，为了降低求幂的复杂度，自然而然就想到快速幂算法,不懂见百度百科—百度
这里只用贪心算法做出来

解法 贪心算法

class Solution {
public:
    int cuttingRope(int n) {
        if(n<=3)
        return n-1;
        long ans=1;
        while(n>4)
        {
            ans*=3;
            ans%=1000000007;
            n-=3;
        }
        return (int)(ans*n%1000000007);
    }
};

时间O(n),空间O(1)