Minimum Cost to Make Array Equal

Minimum Cost to Make Array Equal - Problem

Array Binary Search Greedy Sorting Prefix Sum Hard

You are given two 0-indexed arrays nums and cost consisting each of n positive integers.

You can do the following operation any number of times:

Increase or decrease any element of the array nums by 1.

The cost of doing one operation on the i^th element is cost[i].

Return the minimum total cost such that all the elements of the array nums become equal.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,3,5], cost = [2,3,1]

› Output: 6

💡 Note: Change nums to [3,3,3]: cost = |1-3|×2 + |3-3|×3 + |5-3|×1 = 2×2 + 0×3 + 2×1 = 6

Example 2 — Equal Elements

$ Input: nums = [2,2,2,2], cost = [4,2,8,1]

› Output: 0

💡 Note: All elements are already equal, so no operations needed. Total cost = 0

Example 3 — Large Range

$ Input: nums = [1,10,20], cost = [1,1,1]

› Output: 19

💡 Note: Optimal target is 10: cost = |1-10|×1 + |10-10|×1 + |20-10|×1 = 9 + 0 + 10 = 19

Constraints

n == nums.length
n == cost.length
1 ≤ n ≤ 10⁵
1 ≤ nums[i], cost[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 12 A Amazon 8 M Microsoft 6

The key insight is that the optimal target value is the weighted median of the array. The weighted median approach gives us O(n log n) time by sorting elements and finding the median point. Binary search can also work efficiently by searching the answer space. Time: O(n log n), Space: O(n)

Common Approaches

✓ Binary Search on Answer Space

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

Use binary search to find the optimal target value. The cost function is unimodal (has single minimum), so we can binary search on the answer space by comparing costs at different points.

Brute Force - Try All Targets

⏱️ Time: O(k × n) Space: O(1)

For each possible target value (min to max of nums), calculate the total cost to make all elements equal to that target. Return the minimum cost found.

Weighted Median Approach

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

The optimal target is the weighted median of the array. Sort elements with their costs, then find the point where cumulative cost weight equals half of total weight.

Binary Search on Answer Space — Algorithm Steps

Set search range [min_val, max_val]
Binary search on target values
For each mid, calculate total cost
Move search based on cost comparison

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Range

Start with [min, max] range of nums

Ternary Search

Compare costs at 1/3 and 2/3 points

Converge

Narrow range until optimal target found

Code -

solution.c — C

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

long long calculateCost(int* nums, int* cost, int n, int target) {
    long long total = 0;
    for (int i = 0; i < n; i++) {
        int diff = nums[i] - target;
        if (diff < 0) diff = -diff;
        total += (long long)diff * cost[i];
    }
    return total;
}

long long solution(int* nums, int* cost, int n) {
    int left = nums[0], right = nums[0];
    for (int i = 1; i < n; i++) {
        if (nums[i] < left) left = nums[i];
        if (nums[i] > right) right = nums[i];
    }
    
    while (right - left > 2) {
        int mid1 = left + (right - left) / 3;
        int mid2 = right - (right - left) / 3;
        
        if (calculateCost(nums, cost, n, mid1) > calculateCost(nums, cost, n, mid2)) {
            left = mid1;
        } else {
            right = mid2;
        }
    }
    
    long long minCost = LLONG_MAX;
    for (int target = left; target <= right; target++) {
        long long currentCost = calculateCost(nums, cost, n, target);
        if (currentCost < minCost) {
            minCost = currentCost;
        }
    }
    
    return minCost;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000], cost[1000], n = 0;
    char* token = strtok(line + 1, ",]");
    while (token) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    int m = 0;
    token = strtok(line + 1, ",]");
    while (token) {
        cost[m++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%lld\n", solution(nums, cost, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

log k binary search iterations, each taking O(n) to calculate cost

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for binary search bounds

✓ Linear Space

18.5K Views

Medium Frequency

~25 min Avg. Time

892 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 on Answer Space — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler