Make K-Subarray Sums Equal

Make K-Subarray Sums Equal - Problem

Array Math Greedy Sorting Number Theory Medium

You are given a 0-indexed integer array arr and an integer k. The array arr is circular. In other words, the first element of the array is the next element of the last element, and the last element of the array is the previous element of the first element.

You can do the following operation any number of times:

Pick any element from arr and increase or decrease it by 1.

Return the minimum number of operations such that the sum of each subarray of length k is equal.

A subarray is a contiguous part of the array.

Input & Output

Example 1 — Basic Circular Array

$ Input: arr = [2,5,3,9,5,3], k = 3

› Output: 7

💡 Note: Need to make all 3-subarrays equal: [2,5,3], [5,3,9], [3,9,5], [9,5,3], [5,3,2], [3,2,5]. Optimal solution groups elements by GCD pattern and uses medians.

Example 2 — Small Array

$ Input: arr = [1,4,1,3], k = 2

› Output: 1

💡 Note: 4-subarrays of length 2: [1,4], [4,1], [1,3], [3,1]. Elements at even positions (1,1) and odd positions (4,3) form groups. Operations: |1-1| + |4-3.5| + |1-1| + |3-3.5| = 1

Example 3 — No Operations Needed

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

› Output: 0

💡 Note: All elements are already equal, so all k-subarrays have equal sums. No operations needed.

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ arr[i] ≤ 10⁹
1 ≤ k ≤ arr.length

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 M Microsoft 8

The key insight is that elements at positions with the same remainder when divided by gcd(n,k) must have equal values for all k-subarrays to be equal. Best approach uses mathematical grouping with medians for optimal operations. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Target Sums

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

Generate all possible target sums by trying different combinations of current subarray sums. For each target sum, calculate the operations needed to make all k-subarrays equal to that sum.

Mathematical Approach - GCD Groups

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

Use the mathematical insight that elements at positions with the same remainder when divided by gcd(n,k) must be equal. Group these elements and find the median for minimum operations.

Brute Force - Try All Target Sums — Algorithm Steps

Step 1: Calculate all current k-subarray sums in the circular array
Step 2: Try each possible target sum from minimum to maximum subarray sum
Step 3: For each target, calculate operations needed using system of equations
Step 4: Return minimum operations across all targets

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Current Sums

Find all k-subarray sums in circular array

Try Target Values

Test each possible target sum

Count Operations

Calculate operations needed for each target

Code -

solution.c — C

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

int solution(int* arr, int arrSize, int k) {
    if (k == 1) return 0;
    
    // Calculate all k-subarray sums
    int* sums = (int*)malloc(arrSize * sizeof(int));
    for (int i = 0; i < arrSize; i++) {
        int subarraySum = 0;
        for (int j = 0; j < k; j++) {
            subarraySum += arr[(i + j) % arrSize];
        }
        sums[i] = subarraySum;
    }
    
    int minOps = INT_MAX;
    
    // Find min and max sums
    int minSum = sums[0], maxSum = sums[0];
    for (int i = 0; i < arrSize; i++) {
        if (sums[i] < minSum) minSum = sums[i];
        if (sums[i] > maxSum) maxSum = sums[i];
    }
    
    // Try each possible target sum
    for (int target = minSum; target <= maxSum; target++) {
        int ops = 0;
        int* tempArr = (int*)malloc(arrSize * sizeof(int));
        for (int i = 0; i < arrSize; i++) {
            tempArr[i] = arr[i];
        }
        
        // Try to make all subarrays equal to target
        for (int iteration = 0; iteration < arrSize; iteration++) {
            int changed = 0;
            for (int i = 0; i < arrSize; i++) {
                int currentSum = 0;
                for (int j = 0; j < k; j++) {
                    currentSum += tempArr[(i + j) % arrSize];
                }
                if (currentSum != target) {
                    int diff = target - currentSum;
                    tempArr[i] += diff;
                    ops += abs(diff);
                    changed = 1;
                    break;
                }
            }
            if (!changed) break;
        }
        
        // Verify all subarrays are equal
        int allEqual = 1;
        for (int i = 0; i < arrSize; i++) {
            int currentSum = 0;
            for (int j = 0; j < k; j++) {
                currentSum += tempArr[(i + j) % arrSize];
            }
            if (currentSum != target) {
                allEqual = 0;
                break;
            }
        }
        
        if (allEqual && ops < minOps) {
            minOps = ops;
        }
        
        free(tempArr);
    }
    
    free(sums);
    return minOps == INT_MAX ? 0 : minOps;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Nested loops: O(n) targets × O(n) subarrays × O(n) elements per calculation

⚠ Quadratic Growth

Space Complexity

O(n)

Arrays to store subarray sums and temporary calculations

⚡ Linearithmic Space

29.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force - Try All Target Sums — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler