Minimum Operations to Make Subarray Elements Equal

Minimum Operations to Make Subarray Elements Equal - Problem

Array Hash Table Math Sliding Window Heap (Priority Queue) Medium

You are given an integer array nums and an integer k. You can perform the following operation any number of times:

Increase or decrease any element of nums by 1.

Return the minimum number of operations required to ensure that at least one subarray of size k in nums has all elements equal.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Subarray [4,2,5]: make all equal to 4 → |4-4|+|2-4|+|5-4| = 0+2+1 = 3 operations. Subarray [2,5,3]: make all equal to 3 → |2-3|+|5-3|+|3-3| = 1+2+0 = 3 operations. Minimum is 3.

Example 2 — All Same Elements

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

› Output: 0

💡 Note: Any subarray of size 2 already has all elements equal (both are 1), so 0 operations needed.

Example 3 — Minimum Size

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

› Output: 2

💡 Note: Only one subarray [10,12]. Using median approach: sorted = [10,12], median = 12, operations = |10-12|+|12-12| = 2+0 = 2.

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ k ≤ nums.length
1 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15

The key insight is that the median of any set minimizes the sum of absolute deviations. For each subarray of size k, we find the median and calculate operations needed. Best approach uses sliding window with median optimization achieving O(n·k log k) time, O(k) space.

Common Approaches

✓ Sliding Window with Median

⏱️ Time: O(n·k log k) Space: O(k)

For each subarray of size k, the median minimizes the sum of absolute deviations. Use a sliding window approach to check each subarray and calculate operations needed to make all elements equal to the median.

Optimized Sliding Window with Heaps

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

Maintain two heaps (max heap for smaller half, min heap for larger half) to efficiently find the median as we slide the window. This avoids sorting each subarray from scratch.

Brute Force - Try All Targets

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

Check every subarray of size k, and for each subarray, try every possible target value from the minimum to maximum element in the entire array.

Sliding Window with Median — Algorithm Steps

Slide window of size k across the array
For each window, find the median element
Calculate operations to make all elements equal to median
Return minimum operations across all windows

Visualization

Tap to expand

Step-by-Step Walkthrough

Slide Window

Move window of size k across array

Find Median

Sort subarray to get median as target

Calculate Cost

Sum distances from all elements to median

Code -

solution.c — C

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

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

int solution(int* nums, int numsSize, int k) {
    int minOps = INT_MAX;
    int* temp = (int*)malloc(k * sizeof(int));
    
    // Check each subarray of size k
    for (int i = 0; i <= numsSize - k; i++) {
        // Copy subarray and sort to find median
        for (int j = 0; j < k; j++) {
            temp[j] = nums[i + j];
        }
        qsort(temp, k, sizeof(int), compare);
        int median = temp[k / 2];
        
        // Calculate operations
        int ops = 0;
        for (int j = i; j < i + k; j++) {
            ops += abs(nums[j] - median);
        }
        if (ops < minOps) {
            minOps = ops;
        }
    }
    
    free(temp);
    return minOps;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n·k log k)

O(n-k+1) windows × O(k log k) to sort each window to find median

⚡ Linearithmic

Space Complexity

O(k)

Extra space to store and sort each subarray

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Sliding Window with Median — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler