力扣小白刷题之343题整数拆分

题目描述

将一个正整数 n 拆分为至少两个正整数的和，并使这些整数的乘积最大化。返回你可以获得的最大乘积。
n 不小于 2 且不大于 58。

思路

参考：https://leetcode-cn.com/problems/integer-break/solution/shuang-jie-fa-dong-tai-gui-hua-tan-xin-fa-fu-zhao-/

动态规划
状态数组 dp[i] 表示：将数字 i 拆分为至少两个正整数的和，这些整数的最大乘积。
dp[] 长度为 n + 1，因为数组的索引是从 0 开始，但是数字 0 不存在，dp[0]占一个位置，实际没有意义。初始值是从 1 开始，dp[1] = 1。
外层循环从 2开始遍历一直到 n 停止。内层循环 j 从 1 开始遍历，一直到 i 之前停止，它代表着数字 i 可以拆分成 j + (i - j)。但j * (i - j)不一定是最大乘积，因为 i - j 不一定大于 dp[i - j](数字i - j拆分成整数之和的最大乘积)，这里要选择最大的值作为 dp[i] 的结果。
转移方程：dp[i] = max(dp[i], max(j * dp[i - j], j * (j - i)))
右边的：

1. dp[i] : 分解 i
2. dp[i - j]：继续分解（i - j)
3. max(j * dp[i - j], j * (j - i))：比较dp[i - j] 与 [j - i]，如果[j - i] > dp[j - i]，则不用再分解(i - j)
4. max(dp[i], max(j * dp[i - j], j * (j - i)))：比较 dp[i] 与后者，如果dp[i] > max(j * dp[i - j], j * (j - i))，

推导过程

先研究递归结构，发现有大量重叠子问题，再实现“记忆化搜索”，最后实现使用“动态规划”。即先“自顶向下”思考，再“自底向上”实现。

参考：https://leetcode-cn.com/problems/integer-break/solution/bao-li-sou-suo-ji-yi-hua-sou-suo-dong-tai-gui-hua-/

1. 暴力搜索
对于给定的一个整数 n，穷举它的每一种分解情况，然后会对所有情况，求最大值。
n 可以拆成如下情况：

通过上图，可以得到一个递归表达式：

F(n) = max{i * F(n - i)}, i = 1, 2, ..., n - 1

上述表达式是表明 n - i 需要继续分解的情况，但如果 n - i 比 F(n - i) 要大，显然就不用再继续分解了。故我们还需要比较 i * (n - i) 与 i * F(n - i) 的大小关系。所以完整的表达式应该为：

F(n) = max{i * F(n - i), i * (n - i)}, i = 1, 2, ..., n - 1

这题还可以这样想，对于给定的数 n， F(n) 表示将 n 分解成多个(≥2)整数的最大乘积，那么有以下几种情况：

1. 将 n 分解成两个数：

F(n) = i * (n - i)，(i = 1, 2, ..., n - 1)

2. 将 n 分解成两个以上的数：
   也就是说我们要对 i 和 i - 1 进一步分解，那么就有三种情况(继续分解其中一个或两个都继续分解)，将 i 和 n - i 进一步分解的最大乘积分别记为 F(i) 和 F(n - i)，那么有：
   但是，我们观察上面的表达式，不难发现，当 i 取遍 [1, n - 1]时，由于 i 和 n - i 的取值对称，i * F(n - i) 和 F(i) * (n - i) 的取值集合是一样的，也就是说这两种情况算出来的结果是一样的，所以只取其中一种就可以了。对于F(i) * F(n - i) ，其实这种情况也是不用考虑的，因为 i * F(n - i) 和 i * (n - i)已经包含了所有的分解情况了。那么整个表达式就为：

F(n) = max{i * (n - i), i * F(n - i)}, )，(i = 1, 2, ..., n - 1)

2. 记忆化搜索(备忘录)
暴力搜索非常耗时是因为在递归过程中计算了很多重复值。
如果我们每次求完一个 F(i)，都将其保存起来，下次再求的时候直接读取保存的值就行了，这显然会节省大量时间。
用一个数组memory存放每次的 F(i)，称为备忘录数组
记忆化搜索：将目标 F(n) 不断转化为求F(n - 1)，F(n - 2)，…,F(2)，F(1)，过程中将计算过的值存起来，从上面的递归树中可以看出来这是一个从上到下的过程，一般称之为自顶向下。
代码是递归

3. 动态规划
将自顶向下的思路转换为 自底向上，就可以将递归代码转化为递推

最终代码

时间复杂度： O(N^2)，两层 for 循环
空间复杂度： O(N)。

注意

1. 新建 int数组，int[] dp = new int[n]，数组每个位置的默认值为0
2. 2层循环，内循环即 j 循环时，i 是固定的，每层内循环的第一次循环，右边的
   dp[i] (i≥2) 为默认值 0，然后每次内循环更新一次，取当前次 j 中的最大值，内循环结束后，此次 i 的最大乘积 dp[i] 已经算出来并存入数组，然后i++，继续内循环…以此类推直到 i = n，就可以求出dp[n]