Minimum Cost to Equalize Array - Practice Coding Problems

Minimum Cost to Equalize Array - Problem

Imagine you have an array of integers where each element represents the height of a tower. Your goal is to make all towers the same height using the most cost-effective strategy possible.

You have two operations at your disposal:

Operation 1: Increase any single tower's height by 1 for a cost of cost1
Operation 2: Increase any two different towers' heights by 1 each for a cost of cost2

The challenge is to determine the minimum total cost to equalize all towers to the same height. Since costs can become astronomical for large arrays, return your answer modulo 10⁹ + 7.

Example: If you have towers [1, 3, 4] and cost1 = 2, cost2 = 3, you need to raise the first tower by 3 and second tower by 1. You could use operation 1 four times (cost = 8) or mix operations for potentially lower cost.

Input & Output

example_1.py — Basic Case

$ Input: nums = [4,1], cost1 = 5, cost2 = 2

› Output: 4

💡 Note: Need to increase nums[1] by 3 to match nums[0]=4. We can use one double operation (increases both elements, but nums[0] is already at target) and one single operation. But since we can't increase nums[0] beyond target, we use single operations: 3 * 5 = 15. Actually, with target=4, we need 3 operations on element 1. Using cost2=2 for pairs when possible gives us better cost.

example_2.py — Double Operation Preferred

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

› Output: 6

💡 Note: Target height is 5. Need operations: [3,2,2,2,0] = 9 total. Since cost2 < 2*cost1, we prefer double operations. We can do 4 double operations (cost=4) and 1 single operation (cost=2), total = 6.

example_3.py — Single Array Element

$ Input: nums = [3], cost1 = 1, cost2 = 2

› Output: 0

💡 Note: Array already has equal elements (only one element), so no operations needed.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
1 ≤ cost1, cost2 ≤ 10⁶
Result must be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Assess Situation

Count how much work each tower needs and find the maximum gap

Compare Costs

Decide if team workers (cost2) are better than two solo workers (2*cost1)

Optimize Strategy

Use the more cost-effective approach while respecting constraints

Handle Edge Cases

Account for situations where perfect pairing isn't possible

Key Takeaway

🎯 Key Insight: The optimal strategy depends on cost efficiency - use double operations when cost2 < 2*cost1, but account for balancing constraints between elements.

Asked in

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

The optimal approach uses greedy strategy with mathematical optimization. Key insights: compare cost2 vs 2*cost1 to decide between operations, consider only a few target heights, and handle the constraint that double operations need pairs. The algorithm runs in O(n) time by checking a constant number of targets and calculating costs efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Enumeration	O(n * max_val * total_increments)	O(1)	Try all possible target heights and operation combinations
Greedy with Mathematical Optimization	O(n)	O(1)	Use cost analysis to greedily choose between operation types

Brute Force Enumeration — Algorithm Steps

Find the maximum element as the minimum target height
For each possible target height, calculate total increments needed
Try all combinations of single and double operations
Track the minimum cost across all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Range

Identify possible target heights starting from max element

Calculate Ops

For each target, compute total operations needed

Try Combinations

Test all possible mixes of single and double operations

Track Minimum

Keep track of the lowest cost found

Code -

solution.c — C

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

int minCostToEqualizeArray(int* nums, int numsSize, int cost1, int cost2) {
    const int MOD = 1000000007;
    int maxVal = nums[0], minVal = nums[0];
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > maxVal) maxVal = nums[i];
        if (nums[i] < minVal) minVal = nums[i];
    }
    
    long long minCost = LLONG_MAX;
    
    for (int target = maxVal; target < maxVal + numsSize; target++) {
        long long totalOps = 0;
        long long maxOps = target - minVal;
        
        for (int i = 0; i < numsSize; i++) {
            totalOps += target - nums[i];
        }
        
        long long cost = LLONG_MAX;
        for (long long pairs = 0; pairs <= (totalOps / 2 < maxOps ? totalOps / 2 : maxOps); pairs++) {
            long long remaining = totalOps - 2 * pairs;
            if (remaining >= 0) {
                long long currentCost = pairs * cost2 + remaining * cost1;
                if (currentCost < cost) cost = currentCost;
            }
        }
        
        if (cost < minCost) minCost = cost;
    }
    
    return minCost % MOD;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * max_val * total_increments)

For each target height, we try all possible operation combinations

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track minimum cost

✓ Linear Space

24.3K Views

Medium-High Frequency

~25 min Avg. Time

856 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 Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler