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 a special merge operation any number of times. In each operation, you can select two adjacent elements x and y where x * y ≤ k, and replace both elements with their product x * y.

For example, with array [1, 2, 2, 3] and k = 5:
• You can merge the first two elements: [1, 2, 2, 3] → [2, 2, 3]
• Or merge elements at positions 1 and 2: [1, 2, 2, 3] → [1, 4, 3]
• But you cannot merge the last two elements since 2 * 3 = 6 > 5

Your goal is to find the minimum possible length of the array after performing any number of these operations strategically.

Input & Output

example_1.py — Basic merge operations

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

› Output: 2

💡 Note: We can merge [1,2] to get [2,2,3], then merge [2,2] to get [4,3]. Since 4*3=12 > 5, we cannot merge further. Final array: [4,3] with length 2.

example_2.py — No merges possible

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

› Output: 3

💡 Note: No adjacent pairs can be merged since 3*4=12>6, 4*5=20>6. The array remains [3,4,5] with length 3.

example_3.py — Complete merge possible

$ Input: nums = [1, 1, 2, 2], k = 10

› Output: 1

💡 Note: We can merge the entire array: [1,1,2,2] → [1,2,2] → [2,2] → [4]. The product 1*1*2*2=4 ≤ 10, so we get length 1.

Constraints

1 ≤ nums.length ≤ 20
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ 10⁹
Adjacent elements only: Can only merge consecutive elements in the array

Visualization

Tap to expand

Understanding the Visualization

Identify Segments

Find all possible segments that can be merged completely

Dynamic Programming

Use DP to find minimum partitioning into valid segments

Optimal Solution

The DP solution gives us the minimum possible array length

Key Takeaway

🎯 Key Insight: The problem reduces to finding the optimal way to partition the array into segments where each segment can be completely merged, minimizing the total number of segments.

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses dynamic programming to partition the array into segments that can be completely merged. The key insight is that we need to find the minimum number of segments such that each segment's product ≤ k. Time complexity: O(n³), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Dynamic Programming (Segment-based)	O(n³)	O(n)	Find optimal way to partition array into mergeable segments
Brute Force (Try All Possible Merges)	O(2^n)	O(n)	Recursively try all possible adjacent merges and return minimum length
Dynamic Programming with Memoization	O(2^n)	O(2^n)	Use memoization to avoid recalculating the same subproblems

Optimal Dynamic Programming (Segment-based) — Algorithm Steps

Create DP array where dp[i] = min length for first i elements
For each position i, try all possible segments ending at i
Check if segment from j to i can be merged completely
Update dp[i] with minimum of dp[j] + 1 for valid segments
Return dp[n] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

dp[0] = 0, all others = ∞

Fill DP Table

For each position, try all possible segments

Segment Validation

Check if segment can be merged completely

Update Minimum

Update dp[i] with minimum segments needed

Code -

solution.c — C

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

int canMergeSegment(int* nums, int start, int end, int k) {
    if (start == end) return 1;
    long long product = nums[start];
    for (int i = start + 1; i <= end; i++) {
        product *= nums[i];
        if (product > k) return 0;
    }
    return 1;
}

int minimumArrayLength(int* nums, int numsSize, int k) {
    if (numsSize == 0) return 0;
    
    // dp[i] = minimum length for first i elements
    int* dp = (int*)malloc((numsSize + 1) * sizeof(int));
    for (int i = 0; i <= numsSize; i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = 0;
    
    for (int i = 1; i <= numsSize; i++) {
        // Try all possible segments ending at position i-1
        for (int j = 0; j < i; j++) {
            if (canMergeSegment(nums, j, i - 1, k)) {
                if (dp[j] != INT_MAX && dp[j] + 1 < dp[i]) {
                    dp[i] = dp[j] + 1;
                }
            }
        }
    }
    
    int result = dp[numsSize];
    free(dp);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int count = 0;
    char* token = strtok(line, " ");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    int k = nums[count - 1];
    count--;
    
    printf("%d\n", minimumArrayLength(nums, count, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for trying all segments and O(n) for checking if segment can be merged

⚠ Quadratic Growth

Space Complexity

O(n)

DP array of size n and auxiliary space for segment checking

⚡ Linearithmic Space

32.4K Views

Medium Frequency

~25 min Avg. Time

847 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

Optimal Dynamic Programming (Segment-based) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler