Optimal Division

Optimal Division - Problem

You are given an integer array nums. The adjacent integers in nums will perform the float division. For example, for nums = [2,3,4], we will evaluate the expression "2/3/4".

However, you can add any number of parentheses at any position to change the priority of operations. You want to add these parentheses such that the value of the expression after the evaluation is maximum.

Return the corresponding expression that has the maximum value in string format. Note: your expression should not contain redundant parentheses.

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,3,4]

› Output: "2/(3/4)"

💡 Note: We want to maximize 2/3/4. By adding parentheses as 2/(3/4), we get 2/0.75 = 2.67, which is maximum possible.

Example 2 — Two Elements

$ Input: nums = [2,3]

› Output: "2/3"

💡 Note: With only two elements, no parentheses can be added. The result is simply 2/3.

Example 3 — Single Element

$ Input: nums = [5]

› Output: "5"

💡 Note: With only one element, the expression is just the number itself: 5.

Constraints

1 ≤ nums.length ≤ 10
2 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 12 F Facebook 8

The key insight is that to maximize a division expression a/b/c/d, we should minimize the denominator by grouping as a/(b/c/d). Best approach is the Mathematical Insight method. Time: O(n), Space: O(n)

Common Approaches

✓ Dynamic Programming - All Combinations

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

Use dynamic programming to consider every possible way to split the expression at each division operator. For each split, recursively find the maximum and minimum values for both parts, then combine them.

Mathematical Insight

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

The key insight is that for any expression a/b/c/d/e..., to maximize the result, we want to minimize the denominator. This is achieved by grouping everything after the first division: a/(b/c/d/e...).

Dynamic Programming - All Combinations — Algorithm Steps

Step 1: Use memoization to store maximum and minimum values for each subarray
Step 2: For each range, try splitting at every division point
Step 3: Combine results using division rules to find optimal parenthesization
Step 4: Track the expression string that produces the maximum value

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Expression

Try splitting at each division operator

Recursive Evaluation

Calculate max/min for left and right parts

Combine Results

Find optimal way to combine subproblems

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include <ctype.h>

#define MAXN 11
#define MAXSTR 256

double dpMax[MAXN][MAXN], dpMin[MAXN][MAXN];
char exprMax[MAXN][MAXN][MAXSTR], exprMin[MAXN][MAXN][MAXSTR];

void solution(int* nums, int n, char* result) {
    if (n == 1) {
        sprintf(result, "%d", nums[0]);
        return;
    }
    if (n == 2) {
        sprintf(result, "%d/%d", nums[0], nums[1]);
        return;
    }

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            dpMax[i][j] = -1e18;
            dpMin[i][j] = 1e18;
            exprMax[i][j][0] = '\0';
            exprMin[i][j][0] = '\0';
        }
        dpMax[i][i] = (double)nums[i];
        dpMin[i][i] = (double)nums[i];
        sprintf(exprMax[i][i], "%d", nums[i]);
        sprintf(exprMin[i][i], "%d", nums[i]);
    }

    for (int len = 2; len <= n; len++) {
        for (int i = 0; i <= n - len; i++) {
            int j = i + len - 1;
            for (int k = i; k < j; k++) {
                // Maximize: lMax / rMin
                if (dpMin[k + 1][j] > 0) {
                    double val = dpMax[i][k] / dpMin[k + 1][j];
                    if (val > dpMax[i][j]) {
                        dpMax[i][j] = val;
                        if (k + 1 == j) {
                            sprintf(exprMax[i][j], "%s/%s", exprMax[i][k], exprMin[k + 1][j]);
                        } else {
                            sprintf(exprMax[i][j], "%s/(%s)", exprMax[i][k], exprMin[k + 1][j]);
                        }
                    }
                }
                // Minimize: lMin / rMax
                if (dpMax[k + 1][j] > 0) {
                    double val = dpMin[i][k] / dpMax[k + 1][j];
                    if (val < dpMin[i][j]) {
                        dpMin[i][j] = val;
                        if (k + 1 == j) {
                            sprintf(exprMin[i][j], "%s/%s", exprMin[i][k], exprMax[k + 1][j]);
                        } else {
                            sprintf(exprMin[i][j], "%s/(%s)", exprMin[i][k], exprMax[k + 1][j]);
                        }
                    }
                }
            }
        }
    }

    strcpy(result, exprMax[0][n - 1]);
}

int main() {
    char line[1024];
    fgets(line, sizeof(line), stdin);

    int nums[MAXN], n = 0;
    char* p = line;
    while (*p) {
        if (isdigit(*p) || (*p == '-' && isdigit(*(p + 1)))) {
            nums[n++] = atoi(p);
            while (isdigit(*p) || *p == '-') p++;
        } else {
            p++;
        }
    }

    if (n == 0) {
        printf("\n");
        return 0;
    }

    char result[MAXSTR];
    solution(nums, n, result);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

For each position, we can choose to split or not split, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n²)

Memoization table stores results for all possible subarrays

⚡ Linearithmic Space

23.8K Views

Medium Frequency

~15 min Avg. Time

432 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming - All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler