算法@LeetCode:IntegerBreak

Log

• 【170428】完成 01 版（Python）提交
• 【170501】研究参考答案，并补充笔记

题目

Integer Break

【题目类型备注】

动态规划, 数学

提交

01

【语言】

Python

【时间】

170428

【思路】

大致尝试了拆分 1~8，发现从 5 开始，满足：

1. 某数 num 拆分数的最大乘积大于 num
2. num 要得到最大乘积，不必要拆分过多，尽量少的拆分就能达到效果（当拆分过细，例如有一些部分成为了 1，反而使乘积更小）

表格大概如下对应：

num	prod
0	0
1	0
2	1
3	2
4	4
5	6 = 2 * 3
6	9 = 3 * 3
7	12 = 3 * 4
8	18 = 3 * 6

因此我大致思考：

1. 当我们后面把更大的数 NUM 拆分成 num 和 NUM-num 时，不用管 num 如何拆分，只要用 num 的最大拆分乘积来替代就行了（毕竟最后我们要用的是拆分数的乘积）。这就是当前规模的问题与更小规模的子问题之间的联系。
2. 只进行 2 拆分：即将数字分解为 2 部分即可（例子给的 10 其实也可以拆分成 10 = prod[5] * prod[5]）
3. 对每个数字，如何得到这个最大拆分乘积？最简单的思路就是把所有可能的二拆分对应的乘积列出（例如 10 = 1 + 9 = 2 + 8 = 3 + 7 = 4 + 6 = 5 + 5，然后求出上述所有组合的乘积），然后取最大即可。不过稍微想了一下，可能后期不需要每次都遍历到使用了 2 的二拆分，于是我修改循环为：每次寻找 k 的二拆分时，找到 k/4 对应的二拆分为止

上述算法仅仅是猜想，不能保证这个假设一直成立……

【代码】

class Solution(object):
    def integerBreak(self, n):
        """
        :type n: int
        :rtype: int
        """
        prod = [0, 0, 1, 2, 4]
        if 2 <= n <= 4:
          return prod[n]
        else:
          prod = [0, 0, 2, 3, 4]
          for i in range(5, n+1):
            halfpart = i/2
            maxprod = prod[halfpart] * prod[i - halfpart]
            for newhalf in range(halfpart-1, halfpart/2, -1):
              thisprod = prod[newhalf] * prod[i - newhalf]
              if thisprod > maxprod:
                maxprod = thisprod
            prod.append(maxprod)

        return prod[n]

【结果】

运行时：35 ms

报告链接：https://leetcode.com/submissions/detail/101419655/

不知道其他拥有 LeetCode 帐号的人能不能看到该报告，所以顺便附图如下：

Your runtime beats 96.09 % of python submissions.

然而要多说一句：这个算法恰恰好在 58 之前全部成立，从 59 开始，这个规律就不一定成立了——或者至少说，参考答案给的 59 以后的计算结果，和我自己的程序跑出的 59 的计算结果，是不一致的……

00

参考解法：

首先，这里有一份比较清晰的数学推导，关于为什么最后分解到 2 或 3 为止

• Java
  • 1：DP 解法，和我思路是一致的，区别在于它内层循环遍历是从 1 到 i-1
  • 2：应该是非 DP 解法中思路最清晰的一个了，比 3 还清晰
  • 3：非 DP 解法的另一种写法，解释也还可以
• C++：递归写法，也很清晰

然后我说明一下，为什么题目要限制到 58……因为 Java 等语言声明时限制了变量类型为 int；当 n > 58 时，答案超过 int 上界，发生了上溢；而 Python 代码则由于未指明变量类型，而且使用的是 list，因此并未限制元素的数值边界。我是怎么知道的？因为我发现我和 DP 思路一致，但居然运行结果和提示结果不同；而 DP 解法却和答案一直一致。因此我输出了当 n = 59 时 max() 的各项参数，然后发现了下面的情况。读者看看这两份输出就明白了。

Java 中的输出：

j vs dp[j] 
j: 1 dp[j]: 1
i-j vs dp[i-j] 
i-j: 58 dp[i-j]: 1549681956
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
0 * 1549681956
j vs dp[j] 
j: 2 dp[j]: 1
i-j vs dp[i-j] 
i-j: 57 dp[i-j]: 1162261467
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
1549681956 * -1970444362
j vs dp[j] 
j: 3 dp[j]: 2
i-j vs dp[i-j] 
i-j: 56 dp[i-j]: 774840978
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
1549681956 * -1970444362
j vs dp[j] 
j: 4 dp[j]: 4
i-j vs dp[i-j] 
i-j: 55 dp[i-j]: 516560652
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
1549681956 * 2066242608
j vs dp[j] 
j: 5 dp[j]: 6
i-j vs dp[i-j] 
i-j: 54 dp[i-j]: 387420489
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 6 dp[j]: 9
i-j vs dp[i-j] 
i-j: 53 dp[i-j]: 258280326
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 7 dp[j]: 12
i-j vs dp[i-j] 
i-j: 52 dp[i-j]: 172186884
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 8 dp[j]: 18
i-j vs dp[i-j] 
i-j: 51 dp[i-j]: 129140163
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 9 dp[j]: 27
i-j vs dp[i-j] 
i-j: 50 dp[i-j]: 86093442
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 10 dp[j]: 36
i-j vs dp[i-j] 
i-j: 49 dp[i-j]: 57395628
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 11 dp[j]: 54
i-j vs dp[i-j] 
i-j: 48 dp[i-j]: 43046721
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 12 dp[j]: 81
i-j vs dp[i-j] 
i-j: 47 dp[i-j]: 28697814
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 13 dp[j]: 108
i-j vs dp[i-j] 
i-j: 46 dp[i-j]: 19131876
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 14 dp[j]: 162
i-j vs dp[i-j] 
i-j: 45 dp[i-j]: 14348907
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 15 dp[j]: 243
i-j vs dp[i-j] 
i-j: 44 dp[i-j]: 9565938
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 16 dp[j]: 324
i-j vs dp[i-j] 
i-j: 43 dp[i-j]: 6377292
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 17 dp[j]: 486
i-j vs dp[i-j] 
i-j: 42 dp[i-j]: 4782969
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 18 dp[j]: 729
i-j vs dp[i-j] 
i-j: 41 dp[i-j]: 3188646
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 19 dp[j]: 972
i-j vs dp[i-j] 
i-j: 40 dp[i-j]: 2125764
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 20 dp[j]: 1458
i-j vs dp[i-j] 
i-j: 39 dp[i-j]: 1594323
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 21 dp[j]: 2187
i-j vs dp[i-j] 
i-j: 38 dp[i-j]: 1062882
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 22 dp[j]: 2916
i-j vs dp[i-j] 
i-j: 37 dp[i-j]: 708588
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 23 dp[j]: 4374
i-j vs dp[i-j] 
i-j: 36 dp[i-j]: 531441
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 24 dp[j]: 6561
i-j vs dp[i-j] 
i-j: 35 dp[i-j]: 354294
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 25 dp[j]: 8748
i-j vs dp[i-j] 
i-j: 34 dp[i-j]: 236196
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 26 dp[j]: 13122
i-j vs dp[i-j] 
i-j: 33 dp[i-j]: 177147
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 27 dp[j]: 19683
i-j vs dp[i-j] 
i-j: 32 dp[i-j]: 118098
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 28 dp[j]: 26244
i-j vs dp[i-j] 
i-j: 31 dp[i-j]: 78732
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 29 dp[j]: 39366
i-j vs dp[i-j] 
i-j: 30 dp[i-j]: 59049
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 30 dp[j]: 59049
i-j vs dp[i-j] 
i-j: 29 dp[i-j]: 39366
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 31 dp[j]: 78732
i-j vs dp[i-j] 
i-j: 28 dp[i-j]: 26244
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 32 dp[j]: 118098
i-j vs dp[i-j] 
i-j: 27 dp[i-j]: 19683
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 33 dp[j]: 177147
i-j vs dp[i-j] 
i-j: 26 dp[i-j]: 13122
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 34 dp[j]: 236196
i-j vs dp[i-j] 
i-j: 25 dp[i-j]: 8748
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 35 dp[j]: 354294
i-j vs dp[i-j] 
i-j: 24 dp[i-j]: 6561
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 36 dp[j]: 531441
i-j vs dp[i-j] 
i-j: 23 dp[i-j]: 4374
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 37 dp[j]: 708588
i-j vs dp[i-j] 
i-j: 22 dp[i-j]: 2916
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 38 dp[j]: 1062882
i-j vs dp[i-j] 
i-j: 21 dp[i-j]: 2187
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 39 dp[j]: 1594323
i-j vs dp[i-j] 
i-j: 20 dp[i-j]: 1458
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 40 dp[j]: 2125764
i-j vs dp[i-j] 
i-j: 19 dp[i-j]: 972
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 41 dp[j]: 3188646
i-j vs dp[i-j] 
i-j: 18 dp[i-j]: 729
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 42 dp[j]: 4782969
i-j vs dp[i-j] 
i-j: 17 dp[i-j]: 486
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 43 dp[j]: 6377292
i-j vs dp[i-j] 
i-j: 16 dp[i-j]: 324
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 44 dp[j]: 9565938
i-j vs dp[i-j] 
i-j: 15 dp[i-j]: 243
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 45 dp[j]: 14348907
i-j vs dp[i-j] 
i-j: 14 dp[i-j]: 162
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 46 dp[j]: 19131876
i-j vs dp[i-j] 
i-j: 13 dp[i-j]: 108
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 47 dp[j]: 28697814
i-j vs dp[i-j] 
i-j: 12 dp[i-j]: 81
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 48 dp[j]: 43046721
i-j vs dp[i-j] 
i-j: 11 dp[i-j]: 54
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 49 dp[j]: 57395628
i-j vs dp[i-j] 
i-j: 10 dp[i-j]: 36
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 50 dp[j]: 86093442
i-j vs dp[i-j] 
i-j: 9 dp[i-j]: 27
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 51 dp[j]: 129140163
i-j vs dp[i-j] 
i-j: 8 dp[i-j]: 18
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 52 dp[j]: 172186884
i-j vs dp[i-j] 
i-j: 7 dp[i-j]: 12
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 53 dp[j]: 258280326
i-j vs dp[i-j] 
i-j: 6 dp[i-j]: 9
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 54 dp[j]: 387420489
i-j vs dp[i-j] 
i-j: 5 dp[i-j]: 6
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 55 dp[j]: 516560652
i-j vs dp[i-j] 
i-j: 4 dp[i-j]: 4
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 2066242608
j vs dp[j] 
j: 56 dp[j]: 774840978
i-j vs dp[i-j] 
i-j: 3 dp[i-j]: 2
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 57 dp[j]: 1162261467
i-j vs dp[i-j] 
i-j: 2 dp[i-j]: 1
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * -1970444362
j vs dp[j] 
j: 58 dp[j]: 1549681956
i-j vs dp[i-j] 
i-j: 1 dp[i-j]: 1
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2066242608 * 1549681956

Python 中的输出：

j vs dp[j] 
j: 1 dp[j]: 1
i-j vs dp[i-j] 
i-j: 58 dp[i-j]: 1549681956
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
0 * 1549681956
j vs dp[j] 
j: 2 dp[j]: 1
i-j vs dp[i-j] 
i-j: 57 dp[i-j]: 1162261467
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
1549681956 * 2324522934
j vs dp[j] 
j: 3 dp[j]: 2
i-j vs dp[i-j] 
i-j: 56 dp[i-j]: 774840978
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 4 dp[j]: 4
i-j vs dp[i-j] 
i-j: 55 dp[i-j]: 516560652
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 5 dp[j]: 6
i-j vs dp[i-j] 
i-j: 54 dp[i-j]: 387420489
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 6 dp[j]: 9
i-j vs dp[i-j] 
i-j: 53 dp[i-j]: 258280326
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 7 dp[j]: 12
i-j vs dp[i-j] 
i-j: 52 dp[i-j]: 172186884
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 8 dp[j]: 18
i-j vs dp[i-j] 
i-j: 51 dp[i-j]: 129140163
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 9 dp[j]: 27
i-j vs dp[i-j] 
i-j: 50 dp[i-j]: 86093442
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 10 dp[j]: 36
i-j vs dp[i-j] 
i-j: 49 dp[i-j]: 57395628
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 11 dp[j]: 54
i-j vs dp[i-j] 
i-j: 48 dp[i-j]: 43046721
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 12 dp[j]: 81
i-j vs dp[i-j] 
i-j: 47 dp[i-j]: 28697814
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 13 dp[j]: 108
i-j vs dp[i-j] 
i-j: 46 dp[i-j]: 19131876
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 14 dp[j]: 162
i-j vs dp[i-j] 
i-j: 45 dp[i-j]: 14348907
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 15 dp[j]: 243
i-j vs dp[i-j] 
i-j: 44 dp[i-j]: 9565938
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 16 dp[j]: 324
i-j vs dp[i-j] 
i-j: 43 dp[i-j]: 6377292
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 17 dp[j]: 486
i-j vs dp[i-j] 
i-j: 42 dp[i-j]: 4782969
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 18 dp[j]: 729
i-j vs dp[i-j] 
i-j: 41 dp[i-j]: 3188646
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 19 dp[j]: 972
i-j vs dp[i-j] 
i-j: 40 dp[i-j]: 2125764
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 20 dp[j]: 1458
i-j vs dp[i-j] 
i-j: 39 dp[i-j]: 1594323
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 21 dp[j]: 2187
i-j vs dp[i-j] 
i-j: 38 dp[i-j]: 1062882
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 22 dp[j]: 2916
i-j vs dp[i-j] 
i-j: 37 dp[i-j]: 708588
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 23 dp[j]: 4374
i-j vs dp[i-j] 
i-j: 36 dp[i-j]: 531441
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 24 dp[j]: 6561
i-j vs dp[i-j] 
i-j: 35 dp[i-j]: 354294
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 25 dp[j]: 8748
i-j vs dp[i-j] 
i-j: 34 dp[i-j]: 236196
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 26 dp[j]: 13122
i-j vs dp[i-j] 
i-j: 33 dp[i-j]: 177147
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 27 dp[j]: 19683
i-j vs dp[i-j] 
i-j: 32 dp[i-j]: 118098
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 28 dp[j]: 26244
i-j vs dp[i-j] 
i-j: 31 dp[i-j]: 78732
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 29 dp[j]: 39366
i-j vs dp[i-j] 
i-j: 30 dp[i-j]: 59049
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 30 dp[j]: 59049
i-j vs dp[i-j] 
i-j: 29 dp[i-j]: 39366
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 31 dp[j]: 78732
i-j vs dp[i-j] 
i-j: 28 dp[i-j]: 26244
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 32 dp[j]: 118098
i-j vs dp[i-j] 
i-j: 27 dp[i-j]: 19683
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 33 dp[j]: 177147
i-j vs dp[i-j] 
i-j: 26 dp[i-j]: 13122
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 34 dp[j]: 236196
i-j vs dp[i-j] 
i-j: 25 dp[i-j]: 8748
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 35 dp[j]: 354294
i-j vs dp[i-j] 
i-j: 24 dp[i-j]: 6561
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 36 dp[j]: 531441
i-j vs dp[i-j] 
i-j: 23 dp[i-j]: 4374
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 37 dp[j]: 708588
i-j vs dp[i-j] 
i-j: 22 dp[i-j]: 2916
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 38 dp[j]: 1062882
i-j vs dp[i-j] 
i-j: 21 dp[i-j]: 2187
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 39 dp[j]: 1594323
i-j vs dp[i-j] 
i-j: 20 dp[i-j]: 1458
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 40 dp[j]: 2125764
i-j vs dp[i-j] 
i-j: 19 dp[i-j]: 972
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 41 dp[j]: 3188646
i-j vs dp[i-j] 
i-j: 18 dp[i-j]: 729
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 42 dp[j]: 4782969
i-j vs dp[i-j] 
i-j: 17 dp[i-j]: 486
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 43 dp[j]: 6377292
i-j vs dp[i-j] 
i-j: 16 dp[i-j]: 324
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 44 dp[j]: 9565938
i-j vs dp[i-j] 
i-j: 15 dp[i-j]: 243
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 45 dp[j]: 14348907
i-j vs dp[i-j] 
i-j: 14 dp[i-j]: 162
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 46 dp[j]: 19131876
i-j vs dp[i-j] 
i-j: 13 dp[i-j]: 108
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 47 dp[j]: 28697814
i-j vs dp[i-j] 
i-j: 12 dp[i-j]: 81
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 48 dp[j]: 43046721
i-j vs dp[i-j] 
i-j: 11 dp[i-j]: 54
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 49 dp[j]: 57395628
i-j vs dp[i-j] 
i-j: 10 dp[i-j]: 36
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 50 dp[j]: 86093442
i-j vs dp[i-j] 
i-j: 9 dp[i-j]: 27
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 51 dp[j]: 129140163
i-j vs dp[i-j] 
i-j: 8 dp[i-j]: 18
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 52 dp[j]: 172186884
i-j vs dp[i-j] 
i-j: 7 dp[i-j]: 12
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 53 dp[j]: 258280326
i-j vs dp[i-j] 
i-j: 6 dp[i-j]: 9
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 54 dp[j]: 387420489
i-j vs dp[i-j] 
i-j: 5 dp[i-j]: 6
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 55 dp[j]: 516560652
i-j vs dp[i-j] 
i-j: 4 dp[i-j]: 4
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2066242608
j vs dp[j] 
j: 56 dp[j]: 774840978
i-j vs dp[i-j] 
i-j: 3 dp[i-j]: 2
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 57 dp[j]: 1162261467
i-j vs dp[i-j] 
i-j: 2 dp[i-j]: 1
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 2324522934
j vs dp[j] 
j: 58 dp[j]: 1549681956
i-j vs dp[i-j] 
i-j: 1 dp[i-j]: 1
dp[i] * max(j, dp[j]) * max(i-j, dp[i-j])
2324522934 * 1549681956

自己实现一遍最优解：

• [language]。。。