动态规划:整数拆分,你要怎么拆?

开发 前端
给定一个正整数 n,将其拆分为至少两个正整数的和,并使这些整数的乘积最大化。返回你可以获得的最大乘积。

 [[375522]]

整数拆分

给定一个正整数 n,将其拆分为至少两个正整数的和,并使这些整数的乘积最大化。返回你可以获得的最大乘积。

示例1:

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

示例 2:

  • 输入: 10
  • 输出: 36
  • 解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。
  • 说明: 你可以假设 n 不小于 2 且不大于 58。

思路

看到这道题目,都会想拆成两个呢,还是三个呢,还是四个....

我们来看一下如何使用动规来解决。

动态规划

动规五部曲,分析如下:

1.确定dp数组(dp table)以及下标的含义

dp[i]:分拆数字i,可以得到的最大乘积为dp[i]。

dp[i]的定义讲贯彻整个解题过程,下面哪一步想不懂了,就想想dp[i]究竟表示的是啥!

2.确定递推公式

可以想 dp[i]最大乘积是怎么得到的呢?

其实可以从1遍历j,然后有两种渠道得到dp[i].

一个是j * (i - j) 直接相乘。

一个是j * dp[i - j],相当于是拆分(i - j),对这个拆分不理解的话,可以回想dp数组的定义。

那有同学问了,j怎么就不拆分呢?

j是从1开始遍历,拆分j的情况,在遍历j的过程中其实都计算过了。

那么从1遍历j,比较(i - j) * j和dp[i - j] * j 取最大的。

递推公式:dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));

3.dp的初始化

不少同学应该疑惑,dp[0] dp[1]应该初始化多少呢?

有的题解里会给出dp[0] = 1,dp[1] = 1的初始化,但解释比较牵强,主要还是因为这么初始化可以把题目过了。

严格从dp[i]的定义来说,dp[0] dp[1] 就不应该初始化,也就是没有意义的数值。

拆分0和拆分1的最大乘积是多少?

这是无解的。

这里我只初始化dp[2] = 1,从dp[i]的定义来说,拆分数字2,得到的最大乘积是1,这个没有任何异议!

确定遍历顺序

确定遍历顺序,先来看看递归公式:dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));

dp[i] 是依靠 dp[i - j]的状态,所以遍历i一定是从前向后遍历,先有dp[i - j]再有dp[i]。

枚举j的时候,是从1开始的。i是从3开始,这样dp[i - j]就是dp[2]正好可以通过我们初始化的数值求出来。

所以遍历顺序为:

  1. for (int i = 3; i <= n ; i++) { 
  2.     for (int j = 1; j < i - 1; j++) { 
  3.         dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j)); 
  4.     } 

举例推导dp数组

举例当n为10 的时候,dp数组里的数值,如下:

343.整数拆分

以上动规五部曲分析完毕,C++代码如下:

  1. class Solution { 
  2. public
  3.     int integerBreak(int n) { 
  4.         vector<int> dp(n + 1); 
  5.         dp[2] = 1; 
  6.         for (int i = 3; i <= n ; i++) { 
  7.             for (int j = 1; j < i - 1; j++) { 
  8.                 dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j)); 
  9.             } 
  10.         } 
  11.         return dp[n]; 
  12.     } 
  13. }; 
  • 时间复杂度:O(n^2)
  • 空间复杂度:O(n)

贪心

本题也可以用贪心,每次拆成n个3,如果剩下是4,则保留4,然后相乘,但是这个结论需要数学证明其合理性!

我没有证明,而是直接用了结论。感兴趣的同学可以自己再去研究研究数学证明哈。

给出我的C++代码如下:

  1. class Solution { 
  2. public
  3.     int integerBreak(int n) { 
  4.         if (n == 2) return 1; 
  5.         if (n == 3) return 2; 
  6.         if (n == 4) return 4; 
  7.         int result = 1; 
  8.         while (n > 4) { 
  9.             result *= 3; 
  10.             n -= 3; 
  11.         } 
  12.         result *= n; 
  13.         return result; 
  14.     } 
  15. }; 
  • 时间复杂度O(n)
  • 空间复杂度O(1)

总结

本题掌握其动规的方法,就可以了,贪心的解法确实简单,但需要有数学证明,如果能自圆其说也是可以的。

其实这道题目的递推公式并不好想,而且初始化的地方也很有讲究,我在写本题的时候一开始写的代码是这样的:

  1. class Solution { 
  2. public
  3.     int integerBreak(int n) { 
  4.         if (n <= 3) return 1 * (n - 1); 
  5.         vector<int> dp(n + 1, 0); 
  6.         dp[1] = 1; 
  7.         dp[2] = 2; 
  8.         dp[3] = 3; 
  9.         for (int i = 4; i <= n ; i++) { 
  10.             for (int j = 1; j < i - 1; j++) { 
  11.                 dp[i] = max(dp[i], dp[i - j] * dp[j]); 
  12.             } 
  13.         } 
  14.         return dp[n]; 
  15.     } 
  16. }; 

这个代码也是可以过的!

在解释递推公式的时候,也可以解释通,dp[i] 就等于 拆解i - j的最大乘积 * 拆解j的最大乘积。看起来没毛病!

但是在解释初始化的时候,就发现自相矛盾了,dp[1]为什么一定是1呢?根据dp[i]的定义,dp[2]也不应该是2啊。

但如果递归公式是 dp[i] = max(dp[i], dp[i - j] * dp[j]);,就一定要这么初始化。递推公式没毛病,但初始化解释不通!

虽然代码在初始位置有一个判断if (n <= 3) return 1 * (n - 1);,保证n<=3 结果是正确的,但代码后面又要给dp[1]赋值1 和 dp[2] 赋值 2,这其实就是自相矛盾的代码,违背了dp[i]的定义!

我举这个例子,其实就说做题的严谨性,上面这个代码也可以AC,大体上一看好像也没有毛病,递推公式也说得过去,但是仅仅是恰巧过了而已。

本文转载自微信公众号「代码随想录」,可以通过以下二维码关注。转载本文请联系代码随想录公众号。

 

责任编辑:武晓燕 来源: 代码随想录
相关推荐

2020-07-07 08:02:33

动态规划缓存枚举

2021-01-04 08:37:53

动态规划DP

2022-01-10 11:28:55

数据结构算法DP入门

2018-07-26 14:50:00

数据库MySQL大表优化

2021-01-26 05:39:06

项目模块代码

2021-02-09 09:55:24

动态规划

2021-01-19 05:46:45

背包数组容量

2018-04-04 08:47:16

数据中心基础设施

2021-10-15 09:53:12

工具

2022-09-06 17:58:11

技术双11

2013-03-31 14:24:21

敏捷开发Scrum迭代开发

2023-01-06 08:42:41

动态规划字符

2009-11-17 09:41:49

程序员的学历

2013-11-06 10:04:00

光棍节C2B天猫

2019-06-17 09:49:27

裁员失业品牌

2018-05-23 00:20:29

2021-10-28 18:58:57

动态规划数据结构算法

2022-12-29 08:12:51

动态规划profit

2022-04-19 07:38:14

数组元素指针

2020-11-24 08:08:36

UDP 网络OSI
点赞
收藏

51CTO技术栈公众号