leetcode 剪绳子系列

### 剪绳子一

利用动态规划

状态转移方程

为啥是这个样子？首先

 代表 长度为i的绳子被剪去j，且继续剪（子问题）

 表示长度为i的绳子被剪去j，不剪了的乘积

注意初始化：

n<2 f=0

n==2 f = 1(因为可以分为1 * 1）

n==3 f = 2(因为可以分为1*2)

两种方式：

1. 递归+备忘录（不用备忘录超时，去除重复子问题）
2. dp数组 dp[i]= max(dp[i],max(dp[i-j]*j,(i-j)*j)))

    class Solution {
public:
    int *memo;
    int cutRope(int number) {
        memo = new int[number+1];
        for(int i=0;i<number+1;++i) memo[i]=-1;
        return dp(number);
        
    }
    //递归+memo
    int dp(int number)
    {
        if(number<2) return 0;
        if(number==2) return 1;
        if(number==3) return 2;
        if(memo[number]!=-1) return memo[number];
        int res = -1;
        //从1开始剪！
        for(int i=1;i<number;++i)
        {
            int dp_i = max(dp(number-i)*i,(number-i)*i);
            res = max(res,dp_i);
        }
        memo[number] = res;
        return  memo[number];
    }

### 剪绳子二

绳子长度范围增加，导致结果必须要对1000000007求余，而求余过程导致动态规划失效，因此使用数学推导

class Solution {
public:
    int cuttingRope(int n) {
        // memo = new int[n+1];
        // for(int i=0;i<=n;++i) memo[i] = -1;
        // return dp(n);
        if(n<2) return 0;
        if(n==2) rerurn 1;
        if(n==3) return 2;
        int div = n / 3;
        int rem = n % 3;
        long res = 1;
        for(int i=0;i<div;++i)
        {
            if(i<div-1)
            {
                res*=3;
            }
            else
            {
                if(rem==2)
                {
                    res=res*(rem*3);
                }
                else
                {
                    res *= (rem+3);
                }
            }
            res = res % 1000000007;

        }
        return res;
    }