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. Your goal is to find the minimum number of operations needed to make at least one subarray of size k have all elements equal.

In each operation, you can increase or decrease any element in the array by exactly 1.

Example: If nums = [1, 3, 5, 4] and k = 3, you need to find the cheapest way to make either [1, 3, 5] or [3, 5, 4] have all equal elements.

The key insight is that for any subarray, the optimal target value is the median of that subarray, as it minimizes the total distance to all elements.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: We can choose subarray [3, 5, 4]. Sorted: [3, 4, 5], median = 4. Operations: |3-4| + |5-4| + |4-4| = 1 + 1 + 0 = 2. This is better than subarray [1, 3, 5] which would need 4 operations.

example_2.py — All Equal

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

› Output: 0

💡 Note: Any subarray of size 2 already has all elements equal, so no operations are needed.

example_3.py — Single Element Subarray

$ Input: nums = [1, 5, 9], k = 1

› Output: 0

💡 Note: When k = 1, any subarray of size 1 has only one element, which is already 'equal to itself', so 0 operations needed.

Visualization

Tap to expand

Understanding the Visualization

Find All Groups

Identify all possible groups of k consecutive neighbors

Calculate Meeting Cost

For each group, find the median house and calculate total walking distance

Choose Best Option

Select the group with minimum total walking distance

Key Takeaway

🎯 Key Insight: The median of any group minimizes the sum of absolute deviations - this is a fundamental property in statistics that makes our algorithm optimal!

Time & Space Complexity

Time Complexity

⏱️

O(n² log k)

n subarrays × (k log k) for sorting each subarray to find median

⚠ Quadratic Growth

Space Complexity

O(k)

Space needed to create sorted copy of each subarray

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ k ≤ nums.length
1 ≤ nums[i] ≤ 10⁹
Time limit: 2 seconds

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses the key insight that the median minimizes the sum of absolute deviations. We check each subarray of size k, find its median (by sorting), and calculate the operations needed. The time complexity is O(n² log k) for the basic approach, which can be optimized to O(n log k) using sliding window with heaps to maintain the median efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Brute Force (Using Median)	O(n² log k)	O(k)	Check every subarray of size k but use median as target value
Brute Force (Try All Subarrays)	O(n²×R)	O(1)	Check every subarray of size k and calculate minimum operations for each possible target value
Sliding Window with Heap (Optimal)	O(n log k)	O(k)	Use sliding window technique with heaps to efficiently maintain median

Optimized Brute Force (Using Median) — Algorithm Steps

Iterate through all possible starting positions for subarrays of size k
For each subarray, create a sorted copy to find the median
Use the median as the target value (middle element for odd k, either middle element for even k)
Calculate operations needed to make all elements equal to the median
Keep track of the minimum operations across all subarrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Subarray

Choose a subarray of size k

Sort & Find Median

Sort subarray and pick middle element

Calculate Cost

Sum absolute differences from median

Track Minimum

Keep the best result so far

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 abs_diff(int a, int b) {
    return a > b ? a - b : b - a;
}

int minOperations(int* nums, int numsSize, int k) {
    int minOps = INT_MAX;
    int* subarray = (int*)malloc(k * sizeof(int));
    
    // Check each subarray of size k
    for (int i = 0; i <= numsSize - k; i++) {
        // Copy subarray
        for (int j = 0; j < k; j++) {
            subarray[j] = nums[i + j];
        }
        
        // Find median by sorting
        qsort(subarray, k, sizeof(int), compare);
        int median = subarray[k / 2];
        
        // Calculate operations needed
        int ops = 0;
        for (int j = i; j < i + k; j++) {
            ops += abs_diff(nums[j], median);
        }
        if (ops < minOps) minOps = ops;
    }
    
    free(subarray);
    return minOps;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n² log k)

n subarrays × (k log k) for sorting each subarray to find median

⚠ Quadratic Growth

Space Complexity

O(k)

Space needed to create sorted copy of each subarray

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ k ≤ nums.length
1 ≤ nums[i] ≤ 10⁹
Time limit: 2 seconds

43.2K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Brute Force (Using Median) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler