Integer Break

Integer Break - Problem

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.

Input & Output

Example 1 — Basic Case

$ Input: n = 10

› Output: 36

💡 Note: Break 10 into 3+3+2+2. Product = 3×3×2×2 = 36. This is optimal because we use mostly 3s with 2s to handle the remainder.

Example 2 — Small Number

$ Input: n = 4

› Output: 4

💡 Note: Break 4 into 2+2. Product = 2×2 = 4. Alternative 1+3 gives product 3, and 1+1+2 gives product 2, so 2+2 is optimal.

Example 3 — Edge Case

$ Input: n = 2

› Output: 1

💡 Note: Must break into k>=2 parts, so 2 = 1+1. Product = 1×1 = 1. This is the only valid way to break n=2.

Constraints

2 ≤ n ≤ 58

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8

The key insight is that to maximize the product, we should break the number into mostly 3s with some 2s when needed, because 3 has the optimal product-to-sum ratio. Best approach is the mathematical formula with Time: O(1), Space: O(1)

Common Approaches

✓ Binary Search Answer

⏱️ Time: N/A Space: N/A

Bottom-Up Dynamic Programming

⏱️ Time: O(n²) Space: O(n)

Start from base cases and iteratively build up the solution. For each number i, try all possible ways to break it and use previously computed results.

Brute Force Recursion

⏱️ Time: O(2^n) Space: O(n)

For each number, try breaking it into all possible pairs and recursively solve for each part. This explores every possible combination but has exponential time complexity.

Mathematical Approach

⏱️ Time: O(1) Space: O(1)

Mathematical analysis shows that to maximize the product, we should split the number into as many 3s as possible, with some 2s when needed. This is because 3 has the optimal ratio of sum contribution to product contribution.

Memoization (Top-Down DP)

⏱️ Time: O(n²) Space: O(n)

Same as brute force but store results of subproblems to avoid recalculating them. This reduces time complexity from exponential to polynomial.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

void countFractions(int *arr, int n, double maxVal, int *result) {
    int count = 0;
    int bestNum = 0, bestDen = 0;
    
    for (int i = 0; i < n; i++) {
        int j = i + 1;
        // Find the largest j such that arr[i]/arr[j] <= maxVal
        while (j < n && arr[i] > maxVal * arr[j]) {
            j++;
        }
        
        if (j < n) {
            count += n - j;
            // Track the largest fraction <= maxVal for this i
            if ((double)arr[i] / arr[j] <= maxVal) {
                if (bestDen == 0 || arr[i] * bestDen > bestNum * arr[j]) {
                    bestNum = arr[i];
                    bestDen = arr[j];
                }
            }
        }
    }
    
    result[0] = count;
    result[1] = bestNum;
    result[2] = bestDen;
}

void solution(int *arr, int n, int k, int *result) {
    double left = 0.0, right = 1.0;
    
    while (right - left > 1e-9) {
        double mid = (left + right) / 2;
        int tempResult[3];
        countFractions(arr, n, mid, tempResult);
        int count = tempResult[0];
        
        if (count < k) {
            left = mid;
        } else {
            right = mid;
        }
    }
    
    // Find the actual k-th fraction
    int finalResult[3];
    countFractions(arr, n, right, finalResult);
    result[0] = finalResult[1];
    result[1] = finalResult[2];
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int arr[100];
    int n = 0;
    char *token = strtok(line + 1, ",]");
    while (token != NULL) {
        arr[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k;
    scanf("%d", &k);
    
    int result[2];
    solution(arr, n, k, result);
    printf("[%d,%d]\n", result[0], result[1]);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

182.0K Views

Medium Frequency

~25 min Avg. Time

3.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen