剑指 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

二. 解法

1. 数论方法，
   1.任何大于1的数都可由2和3相加组成（根据奇偶证明）
   2.因为22=14，23>15, 所以将数字拆成2和3，能得到的积最大
   3.因为222<3*3, 所以3越多积越大 时间复杂度O(n/3)， 空间复杂度常数复杂度O(1)
   4.要注意4=3+1=2+2，4分解为2+2得到的积更大

class Solution {
    public int cuttingRope(int n) {
        if(n==2)
            return 1;
        if(n==3)
            return 2;
        return reCuttingRope(n);
    }
    public int reCuttingRope(int n){
        if(n==0)
            return 1;
        if(n==4)
            return 4;
        if(n>=3)
            return 3 * reCuttingRope(n-3);
        else
            return 2 * reCuttingRope(n-2);
    }
}

更简单的：

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

2. 动态规划(C++实现）
   dp[i]表示长度为i的绳子得到的最大乘积为dp[i]
   状态转移方程：dp[i] = max(dp[i-2]*2,dp[i-3]*3)
   初始状态：dp[2]=2,dp[3]=3

class Solution {
public:
    int cuttingRope(int n) {
        if(n==2) return 1;
        if(n==3) return 2;
        vector<int> dp(n+1,0);
        dp[2] = 2;
        dp[3] = 3;
        for(int i=4;i<=n;i++){
            dp[i] = max(dp[i-2]*2,dp[i-3]*3);
        }
        return dp[n];
    }
};

剑指 Offer 14- II. 剪绳子 II
给你一根长度为 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。
示例 1：
输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1
示例 2:
输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36
提示：
2 <= n <= 1000

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

求模之后不能使用动态规划解决，因为max之后的结果已经不准确了。