Minimum Sum of Squared Difference - Practice Coding Problems

Minimum Sum of Squared Difference - Problem

Array Binary Search Greedy Sorting Heap (Priority Queue) Medium

You're given two arrays nums1 and nums2 of equal length, and your goal is to minimize the sum of squared differences between corresponding elements.

The sum of squared difference is calculated as: sum((nums1[i] - nums2[i])²) for all valid indices.

Here's the twist: you can modify elements by adding or subtracting 1:

You can modify elements in nums1 up to k1 times
You can modify elements in nums2 up to k2 times

Strategy: Use your modifications wisely to bring corresponding elements as close to each other as possible. The closer they are, the smaller the squared difference!

Note: Elements can become negative through modifications.

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [1, 2, 3, 4], nums2 = [2, 10, 20, 19], k1 = 0, k2 = 0

› Output: 579

💡 Note: Without any modifications, differences are [1, 8, 17, 15]. Sum of squares = 1² + 8² + 17² + 15² = 1 + 64 + 289 + 225 = 579

example_2.py — With Modifications

$ Input: nums1 = [1, 4, 10, 12], nums2 = [5, 8, 6, 9], k1 = 1, k2 = 1

› Output: 43

💡 Note: Initial differences: [4, 4, 4, 3]. We can modify nums1[2] from 10 to 9 (k1=1) and nums2[2] from 6 to 7 (k2=1), making differences [4, 4, 2, 3]. Sum = 16 + 16 + 4 + 9 = 45. Better strategy: reduce the largest differences first to get 43.

example_3.py — Edge Case

$ Input: nums1 = [1, 0, 1, 1], nums2 = [1, 0, 1, 1], k1 = 3, k2 = 3

› Output: 0

💡 Note: Arrays are already identical, so sum of squared differences is 0. No modifications needed.

Constraints

n == nums1.length == nums2.length
1 ≤ n ≤ 10⁵
0 ≤ nums1[i], nums2[i] ≤ 10⁵
0 ≤ k1, k2 ≤ 10⁹
Elements can become negative after modifications

Visualization

Tap to expand

Understanding the Visualization

Calculate Initial Differences

Find |nums1[i] - nums2[i]| for each position

Binary Search on Max Difference

Find the smallest achievable maximum difference

Apply Greedy Reduction

Reduce largest differences first for maximum impact

Key Takeaway

🎯 Key Insight: The greedy approach works because reducing larger differences has a quadratically greater impact on the final sum than reducing smaller ones.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal approach uses binary search combined with greedy allocation. First, we binary search on the maximum absolute difference we want to achieve. For each candidate maximum difference, we check if it's achievable with our available modifications using a greedy strategy. The key insight is that we should always reduce the largest differences first as this gives the maximum reduction in the sum of squares.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O((k1+n)^n * (k2+n)^n)	O(n)	Try all possible ways to distribute k1 and k2 modifications
Binary Search + Greedy	O(n log(max_diff))	O(n)	Binary search on the answer combined with greedy allocation

Brute Force (Try All Combinations) — Algorithm Steps

Generate all ways to distribute k1 modifications among n elements of nums1
Generate all ways to distribute k2 modifications among n elements of nums2
For each combination, apply modifications and calculate sum of squared differences
Return the minimum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Try every way to distribute k1 and k2 modifications

Calculate Each Sum

For each combination, compute sum of squared differences

Track Minimum

Keep track of the smallest sum found so far

Code -

solution.c — C

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

long long minSum = LLONG_MAX;

void backtrack(int idx, int mods1, int mods2, int* currentNums1, int* currentNums2, int n) {
    if (idx == n) {
        long long currentSum = 0;
        for (int i = 0; i < n; i++) {
            long long diff = currentNums1[i] - currentNums2[i];
            currentSum += diff * diff;
        }
        if (currentSum < minSum) {
            minSum = currentSum;
        }
        return;
    }
    
    for (int mod1 = -mods1; mod1 <= mods1; mod1++) {
        for (int mod2 = -mods2; mod2 <= mods2; mod2++) {
            if (abs(mod1) <= mods1 && abs(mod2) <= mods2) {
                currentNums1[idx] += mod1;
                currentNums2[idx] += mod2;
                backtrack(idx + 1, mods1 - abs(mod1), mods2 - abs(mod2), currentNums1, currentNums2, n);
                currentNums1[idx] -= mod1;
                currentNums2[idx] -= mod2;
            }
        }
    }
}

long long minimumSumOfSquaredDifference(int* nums1, int nums1Size, int* nums2, int nums2Size, int k1, int k2) {
    minSum = LLONG_MAX;
    int* currentNums1 = (int*)malloc(nums1Size * sizeof(int));
    int* currentNums2 = (int*)malloc(nums2Size * sizeof(int));
    
    for (int i = 0; i < nums1Size; i++) {
        currentNums1[i] = nums1[i];
        currentNums2[i] = nums2[i];
    }
    
    backtrack(0, k1, k2, currentNums1, currentNums2, nums1Size);
    
    free(currentNums1);
    free(currentNums2);
    return minSum;
}

Time & Space Complexity

Time Complexity

⏱️

O((k1+n)^n * (k2+n)^n)

For each element, we try all possible modification counts, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Only need to store current modification counts

⚡ Linearithmic Space

31.7K Views

Medium Frequency

~25 min Avg. Time

1.3K 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 Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler