Minimum Cost to Make Arrays Identical - Practice Coding Problems

Minimum Cost to Make Arrays Identical - Problem

You are given two integer arrays arr and brr of length n, and an integer k. Your goal is to transform arr to make it identical to brr using the minimum possible cost.

You have access to two types of operations:

Rearrange Operation (Cost: k): Split arr into any number of contiguous subarrays and rearrange these subarrays in any order. This operation has a fixed cost of k.
Modify Operation (Cost: x): Choose any element in arr and add or subtract a positive integer x to it. The cost of this operation is x.

The key insight is that you can potentially use the rearrange operation to optimally pair elements from arr with elements from brr to minimize the total modification cost, but you need to decide whether the rearrangement cost k is worth it.

Return the minimum total cost to make arr equal to brr.

Input & Output

example_1.py — Python

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

› Output: 3

💡 Note: Without rearrangement: |3-2| + |1-4| + |4-1| = 1 + 3 + 3 = 7. With optimal rearrangement: sort both arrays to get [1,3,4] and [1,2,4], giving cost |1-1| + |3-2| + |4-4| = 0 + 1 + 0 = 1, plus rearrangement cost k=2, total = 3. Since 3 < 7, answer is 3.

example_2.py — Python

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

› Output: 4

💡 Note: Without rearrangement: |1-3| + |2-2| + |3-1| = 2 + 0 + 2 = 4. With rearrangement: both arrays become [1,2,3] when sorted, so modification cost = 0, but total = 0 + 10 = 10. Since 4 < 10, we choose not to rearrange. Answer is 4.

example_3.py — Python

$ Input: arr = [5], brr = [5], k = 1

› Output: 0

💡 Note: Arrays are already identical, so no operations needed. Cost = 0.

Constraints

1 ≤ n ≤ 10³
1 ≤ arr[i], brr[i] ≤ 10⁶
1 ≤ k ≤ 10⁹
Arrays arr and brr have the same length n

Visualization

Tap to expand

Understanding the Visualization

Assess Current State

Calculate the cost of making arrays identical without any rearrangement

Find Optimal Configuration

Sort both arrays to determine the best possible element pairing

Calculate Reorganization Cost

Add the fixed rearrangement cost k to the optimal modification cost

Make Strategic Choice

Choose the strategy that gives minimum total cost

Key Takeaway

🎯 Key Insight: Sorting both arrays independently and pairing elements gives the mathematically minimum possible modification cost, but we must weigh this against the rearrangement cost k to make the optimal decision.

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 31 f Meta 25

The optimal solution uses a greedy approach with sorting. Calculate two costs: (1) keeping original order, and (2) optimal rearrangement by sorting both arrays to create best possible pairing, then adding rearrangement cost k. The key insight is that pairing smallest with smallest elements minimizes sum of absolute differences. Time complexity: O(n log n) due to sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Arrangements)	O(n! × n)	O(n)	Generate all possible rearrangements and find minimum cost
Greedy with Sorting (Optimal)	O(n log n)	O(n)	Sort both arrays to find optimal pairing, compare with original cost

Brute Force (Try All Arrangements) — Algorithm Steps

Generate all n! permutations of arr
For each permutation, calculate sum of |arr[i] - brr[i]|
Consider both: no rearrangement cost vs rearrangement cost + k
Return minimum cost across all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Arrays

Start with arr and target brr

Generate Permutations

Create all possible rearrangements of arr

Calculate Costs

For each arrangement, calculate modification cost

Find Minimum

Choose between no rearrangement vs best rearrangement + k

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

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

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int minCostHelper;
void permute(int* arr, int* brr, int n, int start, int k) {
    if (start == n) {
        int cost = 0;
        for (int i = 0; i < n; i++) {
            cost += abs_val(arr[i] - brr[i]);
        }
        minCostHelper = min(minCostHelper, cost);
        return;
    }
    
    for (int i = start; i < n; i++) {
        swap(&arr[start], &arr[i]);
        permute(arr, brr, n, start + 1, k);
        swap(&arr[start], &arr[i]);
    }
}

int minCostToMakeIdentical(int* arr, int* brr, int n, int k) {
    // Calculate cost without rearrangement
    int noRearrangeCost = 0;
    for (int i = 0; i < n; i++) {
        noRearrangeCost += abs_val(arr[i] - brr[i]);
    }
    
    // Find minimum cost with rearrangement
    minCostHelper = INT_MAX;
    permute(arr, brr, n, 0, k);
    
    int minWithRearrange = minCostHelper + k;
    return min(noRearrangeCost, minWithRearrange);
}

int main() {
    int arr[100], brr[100], n = 0, k;
    char line[1000];
    
    // Read first line
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, " ");
    while (token != NULL) {
        arr[n] = atoi(token);
        token = strtok(NULL, " ");
        n++;
    }
    
    // Read second line
    fgets(line, sizeof(line), stdin);
    token = strtok(line, " ");
    for (int i = 0; i < n; i++) {
        brr[i] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    scanf("%d", &k);
    
    printf("%d\n", minCostToMakeIdentical(arr, brr, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to calculate cost

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation

⚡ Linearithmic Space

52.3K Views

Medium-High Frequency

~12 min Avg. Time

1.8K 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 Arrangements) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler