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

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

✓ Dynamic Programming with Median Optimization

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

This approach uses dynamic programming combined with the key insight that the median minimizes the cost of making all elements in a subarray equal. We precompute costs for all possible subarrays, then use DP to find the optimal selection of k non-overlapping subarrays.

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>
#include <string.h>

static int dp[10001][101];

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

void solve() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int nums[10000];
    int n = 0;
    
    char* token = strtok(line, ",");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    int x, k;
    scanf("%d", &x);
    scanf("%d", &k);
    
    if (n < k * x) {
        printf("-1\n");
        return;
    }
    
    // Precompute costs for all subarrays of size x
    int subarray_costs[n - x + 1];
    for (int i = 0; i <= n - x; i++) {
        int subarray[x];
        for (int j = 0; j < x; j++) {
            subarray[j] = nums[i + j];
        }
        // Sort to find median for optimal target
        int sorted_subarray[x];
        for (int j = 0; j < x; j++) {
            sorted_subarray[j] = subarray[j];
        }
        qsort(sorted_subarray, x, sizeof(int), compare);
        // Use median as target (minimizes sum of absolute deviations)
        int median = sorted_subarray[x / 2];
        int cost = 0;
        for (int j = 0; j < x; j++) {
            int diff = subarray[j] - median;
            cost += (diff < 0) ? -diff : diff;
        }
        subarray_costs[i] = cost;
    }
    
    // DP: dp[i][j] = min cost to select j subarrays from first i positions
    const int INF = INT_MAX;
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= k; j++) {
            dp[i][j] = INF;
        }
    }
    dp[0][0] = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= k; j++) {
            if (dp[i][j] == INF) {
                continue;
            }
            
            // Don't take subarray starting at position i
            if (dp[i + 1][j] > dp[i][j]) {
                dp[i + 1][j] = dp[i][j];
            }
            
            // Take subarray starting at position i (if possible)
            if (i + x <= n && j < k) {
                int new_cost = dp[i][j] + subarray_costs[i];
                if (dp[i + x][j + 1] > new_cost) {
                    dp[i + x][j + 1] = new_cost;
                }
            }
        }
    }
    
    int result = INF;
    for (int i = 0; i <= n; i++) {
        if (dp[i][k] < result) {
            result = dp[i][k];
        }
    }
    printf("%d\n", result == INF ? -1 : result);
}

int main() {
    solve();
    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