剑指 Offer 14- I. 剪绳子

思路

方法一：动态规划

从题目中可以看出，有最优子结构，可以联想到动态规划，其递归树如下：

 可以看出，具有很多重叠子问题。

/*记忆化搜索代码*/
class Solution {
private:
    // 记忆化搜索，自顶向下
    // memo[n]表示分割n获得的乘积最大值
    vector<int> memo;
    int max3(int a, int b, int c) {
        return max(a, max(b,c));
    }
    int breakInteger(int n) {
        if(n == 1)
            return 1;

        if(memo[n] != -1)
            return memo[n];

        int res = -1;
        for(int i = 1; i < n; ++i) {
            res = max3(res, i*(n-i), i * breakInteger(n-i));
        }
        memo[n] = res;
        return memo[n];
        
    }
public:
    int integerBreak(int n) {
        memo = vector<int>(n+1, -1);
        return breakInteger(n);
    }
};

/*动态规划代码*/
class Solution {
private:
    // 动态规划，自底向上
    // 求三个数中的最大值
    int max3(int a, int b, int c) {
        return max(a, max(b,c));
    }
    
public:
    int integerBreak(int n) {
        vector<int> memo(n+1, -1);
        // memo[i]表示分割i获得的乘积最大值
        // 题目中说了n>=2，所以这里不能写memo[3]=2,否则当输入的n是2时会越界
        memo[1] = 1;
        memo[2] = 1;
        for(int i = 3; i <= n; ++i) {
            for(int j = 1; j < i; ++j) {
                memo[i] = max3(memo[i], j*(i-j), j*memo[i-j]);
            }
        }
        return memo[n];
    }
};

复杂度分析

记忆化搜索：

时间复杂度：O(n²)，因为breakInteger递归函数中有一个n次循环，每个memo[i]的值只会被计算一次，不会重复递归计算相同的memo[i] (因为相同的直接返回了)，所以时间复杂度为O(n²)

空间复杂度：O(n)

动态规划：

时间复杂度：O(n²)

空间复杂度：O(n)

方法二：数学

以下证明来自：《剑指offer(第2版)》，面试题14- I. 剪绳子（数学推导 / 贪心思想，清晰图解）

更详细的数学证明见：力扣官方题解 - 整数拆分

class Solution {
public:
    int cuttingRope(int n) {
        if(n <= 3)  
            return n-1;
        int res = 1;
        while(n > 4)
        {
            n    = n - 3;           //尽可能地多剪长度为3的绳子
            res  = res * 3;         
        }
        return res * n;
    }
};

参考

力扣官方题解 - 整数拆分

c++ dp和贪心 -z

面试题14- I. 剪绳子（数学推导 / 贪心思想，清晰图解）