Minimum Cost to Make Arrays Identical

Minimum Cost to Make Arrays Identical - Problem

You are given two integer arrays arr and brr of length n, and an integer k.

You can perform the following operations on arr any number of times:

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

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

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Direct adjustment: |1-2| + |3-1| + |2-3| = 1 + 2 + 1 = 4. Sort both arrays: [1,2,3] and [1,2,3], cost = k + 0 = 1. Minimum is 1.

Example 2 — High Rearrangement Cost

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

› Output: 5

💡 Note: Direct adjustment: |2-1| + |4-2| + |1-3| = 1 + 2 + 2 = 5. Sort cost: k + |1-1| + |2-2| + |4-3| = 10 + 0 + 0 + 1 = 11. Choose direct adjustment: 5.

Example 3 — Already Optimal

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

› Output: 0

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

Constraints

1 ≤ n ≤ 10⁵
-10⁶ ≤ arr[i], brr[i] ≤ 10⁶
1 ≤ k ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to compare two strategies: direct adjustment vs optimal rearrangement. Best approach is greedy comparison between sorting cost and direct cost. Time: O(n log n), Space: O(n)

Common Approaches

✓ Compare Two Strategies

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

Calculate two costs: direct adjustment without rearrangement, and optimal rearrangement (sorting) plus adjustment. The key insight is that if we rearrange, the optimal way is to sort both arrays and pair them up.

Try All Rearrangements

⏱️ Time: O(2^n × n!) Space: O(n)

Generate all possible ways to split and rearrange arr, then calculate the adjustment cost for each arrangement. This explores every possible combination but is extremely inefficient.

Compare Two Strategies — Algorithm Steps

Calculate direct adjustment cost
Calculate sort + adjustment cost
Return minimum of both strategies

Visualization

Tap to expand

Step-by-Step Walkthrough

Strategy 1: Direct

Calculate cost without rearrangement

Strategy 2: Sort

Sort both arrays and calculate k + adjustment cost

Choose Minimum

Return the cheaper option

Code -

solution.c — C

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

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int solution(int* arr, int* brr, int n, int k) {
    // Strategy 1: No rearrangement, direct adjustment
    int directCost = 0;
    for (int i = 0; i < n; i++) {
        directCost += abs_val(arr[i] - brr[i]);
    }
    
    // Strategy 2: Optimal rearrangement (sort both) + adjustment
    int* arrSorted = (int*)malloc(n * sizeof(int));
    int* brrSorted = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        arrSorted[i] = arr[i];
        brrSorted[i] = brr[i];
    }
    
    qsort(arrSorted, n, sizeof(int), compare);
    qsort(brrSorted, n, sizeof(int), compare);
    
    int sortCost = k;
    for (int i = 0; i < n; i++) {
        sortCost += abs_val(arrSorted[i] - brrSorted[i]);
    }
    
    free(arrSorted);
    free(brrSorted);
    
    return directCost < sortCost ? directCost : sortCost;
}

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

int main() {
    char line[1000];
    
    // Parse arr
    fgets(line, sizeof(line), stdin);
    int arr[100], n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9' || token[0] == '-') {
            arr[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    // Parse brr
    fgets(line, sizeof(line), stdin);
    int brr[100], m = 0;
    token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9' || token[0] == '-') {
            brr[m++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(arr, brr, n, k);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting dominates the time complexity

⚡ Linearithmic

Space Complexity

O(n)

Space for sorted copies of arrays

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Compare Two Strategies — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler