Minimum Sum of Squared Difference

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

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

✓ Binary Search + Greedy

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

Use binary search to find the minimum possible maximum absolute difference, then greedily allocate modifications to achieve this target.

Brute Force (Try All Combinations)

⏱️ Time: O((k1+n)^n * (k2+n)^n) Space: O(n)

Generate all possible combinations of how to distribute k1 modifications among nums1 elements and k2 modifications among nums2 elements, then calculate the minimum sum of squared differences.

Binary Search + Greedy — Algorithm Steps

Calculate initial differences between corresponding elements
Binary search on the maximum absolute difference we want to achieve
For each candidate maximum difference, check if it's achievable with given k1, k2
Use greedy strategy to minimize modifications needed
Return the minimum sum of squared differences achievable

Visualization

Tap to expand

Step-by-Step Walkthrough

Set Search Range

Binary search between 0 and maximum initial difference

Check Feasibility

For each candidate, check if achievable with given operations

Apply Greedily

Use greedy strategy to achieve the target maximum difference

Code -

solution.c — C

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

static int diffs[100000];
static int result_diffs[100000];

int canAchieve(int* diffs, int n, int maxDiff, int operations) {
    long long needed = 0;
    for (int i = 0; i < n; i++) {
        if (diffs[i] > maxDiff) {
            needed += diffs[i] - maxDiff;
        }
    }
    return needed <= operations;
}

int max_value(int* arr, int n) {
    int max = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

int min(int a, int b) {
    return a < b ? a : b;
}

long long minimumSumOfSquaredDifference(int* nums1, int nums1Size, int* nums2, int nums2Size, int k1, int k2) {
    int n = nums1Size;
    
    for (int i = 0; i < n; i++) {
        diffs[i] = abs(nums1[i] - nums2[i]);
    }
    
    int operations = k1 + k2;
    
    // If no differences, return 0
    int allZero = 1;
    for (int i = 0; i < n; i++) {
        if (diffs[i] != 0) {
            allZero = 0;
            break;
        }
    }
    if (allZero) {
        return 0;
    }
    
    // If we have enough operations to make all differences 0
    long long sumDiffs = 0;
    for (int i = 0; i < n; i++) {
        sumDiffs += diffs[i];
    }
    if (sumDiffs <= operations) {
        return 0;
    }
    
    // Binary search for minimum achievable maximum difference
    int left = 0, right = max_value(diffs, n);
    
    while (left < right) {
        int mid = (left + right) / 2;
        if (canAchieve(diffs, n, mid, operations)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    int maxDiff = left;
    int remaining = operations;
    
    // Create a copy to modify
    for (int i = 0; i < n; i++) {
        result_diffs[i] = diffs[i];
    }
    
    // Reduce all differences > maxDiff to maxDiff
    for (int i = 0; i < n; i++) {
        if (result_diffs[i] > maxDiff) {
            int reduction = result_diffs[i] - maxDiff;
            result_diffs[i] = maxDiff;
            remaining -= reduction;
        }
    }
    
    // Use remaining operations to reduce some maxDiff values to maxDiff-1
    if (remaining > 0 && maxDiff > 0) {
        int count_at_max = 0;
        for (int i = 0; i < n; i++) {
            if (result_diffs[i] == maxDiff) {
                count_at_max++;
            }
        }
        int reduce_count = min(count_at_max, remaining);
        
        int reduced = 0;
        for (int i = 0; i < n; i++) {
            if (result_diffs[i] == maxDiff && reduced < reduce_count) {
                result_diffs[i] = maxDiff - 1;
                reduced++;
            }
        }
    }
    
    long long result = 0;
    for (int i = 0; i < n; i++) {
        result += (long long)result_diffs[i] * result_diffs[i];
    }
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '\n' && *p != '\0') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == '\n' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    int nums1[1000], nums2[1000];
    int nums1Size, nums2Size;
    int k1, k2;
    
    fgets(line, sizeof(line), stdin);
    parseArray(line, nums1, &nums1Size);
    
    fgets(line, sizeof(line), stdin);
    parseArray(line, nums2, &nums2Size);
    
    scanf("%d", &k1);
    scanf("%d", &k2);
    
    long long result = minimumSumOfSquaredDifference(nums1, nums1Size, nums2, nums2Size, k1, k2);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log(max_diff))

Binary search on maximum difference (log factor) times checking feasibility (n factor)

✓ Linear Growth

Space Complexity

O(n)

Space for storing differences and modifications needed

⚡ 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

Binary Search + Greedy — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler