Minimum Operations to Make Elements Within K Subarrays Equal

Minimum Operations to Make Elements Within K Subarrays Equal - Problem

Array Hash Table Math Dynamic Programming Sliding Window Heap (Priority Queue) Hard

You're given an integer array nums and two integers x and k. Your mission is to transform this array into one that contains at least k non-overlapping subarrays of size exactly x, where all elements within each subarray are equal.

You can perform the following operation any number of times (including zero):

Increase or decrease any element of nums by 1

For example, if nums = [1, 3, 2, 4, 5], x = 2, and k = 2, you need to create at least 2 non-overlapping subarrays of size 2 where all elements in each subarray are equal. One possible solution is [2, 2, 2, 2, 5] with subarrays [2,2] and [2,2], requiring 3 operations total.

Return the minimum number of operations needed to achieve this goal.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: We need 2 non-overlapping subarrays of size 2. We can use [1,3] and [4,5]. To make [1,3] equal, we change to [2,2] (cost=2). To make [4,5] equal, we change to [4,4] (cost=1). Total cost = 3.

example_2.py — Impossible Case

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

› Output: -1

💡 Note: We need 1 subarray of size 3, but the array only has 2 elements. This is impossible, so return -1.

example_3.py — Optimal Placement

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

› Output: 0

💡 Note: We can use [1,1], [2,2], and [3,3] as our 3 subarrays. Each already has equal elements, so no operations needed. Total cost = 0.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁵
1 ≤ x ≤ nums.length
1 ≤ k ≤ nums.length / x
All subarrays must be non-overlapping and of size exactly x

Visualization

Tap to expand

Understanding the Visualization

Identify Rooms

Find all possible locations for k rooms of size x

Calculate Costs

For each room, use median value to minimize adjustment cost

Select Optimally

Use DP to choose k non-overlapping rooms with minimum total cost

Final Gallery

Achieve k exhibition rooms with equal-value paintings

Key Takeaway

🎯 Key Insight: The median value minimizes adjustment costs for any subarray, and dynamic programming finds the optimal selection of non-overlapping subarrays to achieve the required k exhibition rooms with minimum total operations.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 24

This problem requires dynamic programming combined with the key insight that the median minimizes adjustment costs. We precompute costs for all possible subarrays using their median as the target value, then use DP to select the optimal combination of k non-overlapping subarrays with minimum total operations.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Median Optimization	O(n²k)	O(nk)	Use DP to select optimal non-overlapping subarrays with median as target value

Dynamic Programming with Median Optimization — Algorithm Steps

Precompute the cost for each possible subarray of size x using median as target
Use DP where dp[i][j] represents minimum cost to select j subarrays from first i positions
For each position, decide whether to include a subarray ending at that position
Return dp[n][k] as the minimum cost to select k subarrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Precompute Costs

Calculate minimum cost for each subarray using median

DP State

dp[i][j] = min cost for j subarrays in first i positions

Transition

For each position, decide whether to include a subarray

Result

dp[n][k] gives the minimum cost for k subarrays

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int minimumOperations(int* nums, int n, int x, int k) {
    if (n < k * x) return -1;
    
    // Precompute costs for all subarrays of size x
    int costsSize = n - x + 1;
    int costs[costsSize][2];  // [start_pos, cost]
    
    for (int i = 0; i <= n - x; i++) {
        int subarray[x];
        for (int j = 0; j < x; j++) {
            subarray[j] = nums[i + j];
        }
        qsort(subarray, x, sizeof(int), compare);
        
        int median = subarray[x / 2];
        int cost = 0;
        for (int j = 0; j < x; j++) {
            cost += abs(subarray[j] - median);
        }
        costs[i][0] = i;
        costs[i][1] = cost;
    }
    
    // DP: dp[i][j] = min cost to select j subarrays from first i positions
    int dp[n + 1][k + 1];
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= k; j++) {
            dp[i][j] = INT_MAX;
        }
    }
    dp[0][0] = 0;
    
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= k; j++) {
            // Don't take any subarray ending at position i-1
            dp[i][j] = dp[i-1][j];
            
            // Try taking a subarray ending at position i-1
            if (i >= x && j > 0) {
                int startPos = i - x;
                for (int idx = 0; idx < costsSize; idx++) {
                    if (costs[idx][0] == startPos && dp[startPos][j-1] != INT_MAX) {
                        int newCost = dp[startPos][j-1] + costs[idx][1];
                        if (newCost < dp[i][j]) {
                            dp[i][j] = newCost;
                        }
                    }
                }
            }
        }
    }
    
    return dp[n][k] == INT_MAX ? -1 : dp[n][k];
}

int main() {
    int nums[] = {1, 3, 2, 4, 5};
    int n = 5, x = 2, k = 2;
    printf("%d\n", minimumOperations(nums, n, x, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²k)

We compute costs for O(n) subarrays, then DP takes O(nk) with O(n) work per state

⚠ Quadratic Growth

Space Complexity

O(nk)

DP table of size n×k plus space for precomputed costs

⚡ Linearithmic Space

54.3K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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 with Median Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler