Given an integer n, break it into the sum of k positive integers, where k >= 2, and maximize the product of those integers.
Return the maximum product you can get.
Example 1:
Input: n = 2 Output: 1 Explanation: 2 = 1 + 1, 1 × 1 = 1.
Example 2:
Input: n = 10 Output: 36 Explanation: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36.
Constraints:
2 <= n <= 58The dynamic programming approach involves creating an array dp where dp[i] represents the maximum product obtainable for the integer i. The idea is to iterate through numbers from 2 to n and for each number, explore all possible ways to split it into two positive integers j and i-j. The solution for each i is derived by taking the maximum of j * (i-j) or j * dp[i-j] for all j from 1 to i-1.
This C code defines a dynamic programming approach to solving the integer break problem. We initialize an array dp, where dp[i] is the maximum product obtainable for integer i. A nested loop calculates the maximum product for each integer by checking the product of all possible splits (j * (i-j) and j * dp[i-j]).
C++
Java
Python
C#
JavaScript
Time Complexity: O(n^2) because of the nested loop iterating through i and j.
Space Complexity: O(n) for the dp array.
The mathematical approach relies on the observation that numbers are best broken down into 2s and 3s to maximize their product. In particular, the number 3 plays a critical role. For any number greater than 4, it is beneficial to use as many 3s as possible, because any larger piece can be expressed as 3k + r, where adding more 3s generally yields a larger product (e.g., breaking 4 into 2 + 2 is optimal, compared to using one 3 and a 1). The approach is to keep factoring out 3 from n as long as the remaining part is not less than 4, then multiply the results together to get the maximum product.
This C code snippet uses a mathematical approach to solve the integer break problem. Instead of solving it iteratively, we repeatedly factor out 3 from the integer until the remaining integer is less or equal to 4, at which point the product is simply multiplied by the final remainder.
C++
Java
Python
C#
JavaScript
Time Complexity: O(log n), as we repeatedly subtract 3.
Space Complexity: O(1) since no extra space is used besides variables.
| Approach | Complexity |
|---|---|
| Dynamic Programming Approach | Time Complexity: O(n^2) because of the nested loop iterating through |
| Mathematical Approach | Time Complexity: O(log n), as we repeatedly subtract 3. |
Integer Break - Dynamic Programming - Leetcode 343 - Python • NeetCode • 33,662 views views
Watch 9 more video solutions →Practice Integer Break with our built-in code editor and test cases.
Practice on FleetCode