Minimizing Array After Replacing Pairs With Their Product

Minimizing Array After Replacing Pairs With Their Product - Problem

Given an integer array nums and an integer k, you can perform the following operation on the array any number of times:

Select two adjacent elements of the array like x and y, such that x * y <= k, and replace both of them with a single element with value x * y.

For example, in one operation the array [1, 2, 2, 3] with k = 5 can become [1, 4, 3] or [2, 2, 3], but cannot become [1, 2, 6] because 2 * 3 = 6 > 5.

Return the minimum possible length of nums after any number of operations.

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,3,5,4], k = 10

› Output: 3

💡 Note: We can merge 2×3=6 to get [6,5,4]. Cannot merge 6×5=30 > 10 or 5×4=20 > 10. Final length is 3.

Example 2 — Multiple Merges

$ Input: nums = [1,2,2,3], k = 5

› Output: 2

💡 Note: Merge 1×2=2 to get [2,2,3]. Then merge 2×2=4 to get [4,3]. Cannot merge 4×3=12 > 5. Final length is 2.

Example 3 — No Merges Possible

$ Input: nums = [7,8,9], k = 10

› Output: 3

💡 Note: 7×8=56 > 10 and 8×9=72 > 10. No adjacent pairs can be merged. Original length 3 remains.

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that we can use a greedy approach to merge adjacent elements from left to right when their product is ≤ k. This works because merging earlier elements doesn't prevent optimal merges later. Best approach is greedy left-to-right merging. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Combinations

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

For each pair of adjacent elements, if their product is <= k, try merging them and recursively solve the remaining array. Take the minimum across all possibilities.

Greedy - Left to Right Merging

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

Iterate through the array and whenever two adjacent elements can be merged (product <= k), merge them immediately. This greedy approach works because merging earlier doesn't prevent better merges later.

Memoization - Cache Subproblems

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

Cache results for each array state to avoid redundant calculations. Convert array to string key for memoization.

Brute Force - Try All Combinations — Algorithm Steps

For each adjacent pair (i, i+1)
If nums[i] * nums[i+1] <= k, merge them
Recursively solve the new array
Return minimum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with original array

Try All Merges

For each adjacent pair that can merge, create new array

Recursively Solve

Find minimum length from all possibilities

Code -

solution.c — C

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

int solve(int* arr, int size, int k) {
    if (size <= 1) {
        return size;
    }
    
    int minLen = size;
    for (int i = 0; i < size - 1; i++) {
        if ((long long)arr[i] * arr[i + 1] <= k) {
            int* newArr = (int*)malloc(sizeof(int) * (size - 1));
            int idx = 0;
            for (int j = 0; j < i; j++) {
                newArr[idx++] = arr[j];
            }
            newArr[idx++] = arr[i] * arr[i + 1];
            for (int j = i + 2; j < size; j++) {
                newArr[idx++] = arr[j];
            }
            int result = solve(newArr, size - 1, k);
            if (result < minLen) {
                minLen = result;
            }
            free(newArr);
        }
    }
    
    return minLen;
}

int solution(int* nums, int numsSize, int k) {
    return solve(nums, numsSize, k);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int numsSize = 0;
    
    // Parse JSON array format
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++; // Find opening bracket
    if (*ptr) ptr++; // Skip opening bracket
    
    char num[20];
    int numIdx = 0;
    while (*ptr && *ptr != ']') {
        if (isdigit(*ptr)) {
            num[numIdx++] = *ptr;
        } else if (*ptr == ',' || *ptr == ']') {
            if (numIdx > 0) {
                num[numIdx] = '\0';
                nums[numsSize++] = atoi(num);
                numIdx = 0;
            }
        }
        ptr++;
    }
    if (numIdx > 0) {
        num[numIdx] = '\0';
        nums[numsSize++] = atoi(num);
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each position can be merged or not merged, leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth can go up to n levels

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler