给定一个正整数 n ，将其拆分为 k 个 正整数 的和（ k >= 2 ），并使这些整数的乘积最大化。

返回 你可以获得的最大乘积 。

示例 1:

输入: n = 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1。

示例 2:

输入: n = 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。

提示:

2 <= n <= 58

里程碑意义

解题思路：

1、典型动态规划题型， 即前面所算的的值，对推导新值有铺垫作用

2、设立dp数组dp[i] = x即拆分i可以获得的最大乘积为x

3、初始值dp[2] = 1 * 1 = 1

4、进一步推导

dp[3] = max(dp[2] * 1, 2 * 1)
dp[4] = max(dp[3] * 1，dp[2] * d[2], dp[2] * 2, dp[1] * 3, 2 * 2,  3 * 1)
无非就是拆与不拆

5、再加上一些大胆的猜想不难看出dp[i]可以不拆即（i- j) * j也可以拆即dp[i - j] * dp[j]或者dp[i - j] *j取其中最大值即可

代码：

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

可以看出时间还是有些许长，仔细分析下面两行代码：

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

可以看出dp[j]是没必要拆开的，如果它要拆开的话完全可以放在dp[i - j]里，也就是说咱们写了一个重复的语句

例如：
dp[6] * dp[4] = 3 * 3 * 2* 2
等效于
dp[8] * 2 = 3 * 3 * 2 * 2

当然也可以这样理解：

对于正整数 i，当 i≥2 时，可以拆分成至少两个正整数的和。令 j 是拆分出的第一个正整数，则剩下的部分是 i−j，i−j 可以不继续拆分，或者继续拆分成至少两个正整数的和。

优化代码：

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

举一反三拆分dp[j]必然也没有问题

代码：

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