Minimum Total Cost to Make Arrays Unequal

Minimum Total Cost to Make Arrays Unequal - Problem

Minimum Total Cost to Make Arrays Unequal

You are given two 0-indexed integer arrays nums1 and nums2, both of equal length n. Your mission is to ensure that no element at the same index in both arrays is equal.

You can perform swap operations on nums1 - swap any two elements at indices i and j. The cost of this operation is i + j (sum of the indices).

Goal: Find the minimum total cost to make nums1[i] != nums2[i] for all indices 0 ≤ i < n.

Example:
nums1 = [1,2,3,4]
nums2 = [1,2,3,4]
We need to swap elements in nums1 to ensure no position has matching values. If impossible, return -1.

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [1,2,3,4], nums2 = [1,3,2,4]

› Output: 3

💡 Note: Bad positions are at indices 0 and 3 (where nums1[i] == nums2[i]). We need to include these positions in swaps. The minimum cost is 0 + 3 = 3.

example_2.py — No Solution

$ Input: nums1 = [2,2,2,1], nums2 = [1,2,2,2]

› Output: 3

💡 Note: Bad positions are at indices 1 and 2, both with value 2. Since value 2 appears in 2 out of 2 bad positions (100%), we need 2 additional help positions. We can use positions 0 and 3 as help positions since nums1[0]=2≠1=nums2[0] creates a mismatch and nums1[3]=1≠2=nums2[3]. Total cost = 1 + 2 + 0 + 3 = 6. Wait, let me recalculate: bad positions [1,2] cost 3, but we need help positions that don't involve the dominant value 2. Position 0: nums1[0]=2 (involves 2), position 3: nums1[3]=1, nums2[3]=2 (involves 2). Actually, this case should return -1 as no valid help positions exist.

example_3.py — Already Valid

$ Input: nums1 = [1,2,3,4], nums2 = [2,1,4,3]

› Output: 0

💡 Note: Arrays already satisfy nums1[i] != nums2[i] for all i, so no swaps needed.

Constraints

n == nums1.length == nums2.length
1 ≤ n ≤ 10⁵
1 ≤ nums1[i], nums2[i] ≤ 10⁶
Important: The cost of swapping indices i and j is i + j

Visualization

Tap to expand

Asked in

G Google 12 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal solution uses a greedy approach with hash counting. First identify all 'bad positions' where nums1[i] == nums2[i]. Count the frequency of each conflicting value. If the most frequent value appears more than half the time in bad positions, we need additional 'helper' positions. The minimum cost is the sum of all required position indices, prioritizing lower indices for cost optimization.

Common Approaches

✓ Brute Force (Try All Swaps)

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

Generate all possible ways to swap elements in nums1 and check if any configuration satisfies the condition nums1[i] != nums2[i] for all i. Track the minimum cost among valid configurations.

Greedy with Hash Counting (Optimal)

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

First identify all positions where nums1[i] == nums2[i] (bad positions). Count frequency of values in bad positions. The most frequent value needs special handling. Use greedy approach to swap from lowest-cost positions first.

Brute Force (Try All Swaps) — Algorithm Steps

Generate all possible swap combinations using backtracking
For each combination, calculate total swap cost
Check if resulting nums1 satisfies the unequal condition
Track minimum cost among valid solutions
Return minimum cost or -1 if no solution exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original arrays and identify conflicts

Try All Swaps

Generate all possible swap combinations

Check Validity

For each combination, verify no conflicts exist

Track Minimum

Keep track of the lowest cost valid solution

Code -

solution.c — C

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

static int bad_positions[100000];
static int values[100000];
static int counts[100000];
static int help_positions[100000];

long long minimumTotalCost(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    int n = nums1Size;
    
    int bad_count = 0;
    for (int i = 0; i < n; i++) {
        if (nums1[i] == nums2[i]) {
            bad_positions[bad_count++] = i;
        }
    }
    
    if (bad_count == 0) {
        return 0;
    }
    
    int unique_count = 0;
    for (int i = 0; i < bad_count; i++) {
        int val = nums1[bad_positions[i]];
        int found = 0;
        for (int j = 0; j < unique_count; j++) {
            if (values[j] == val) {
                counts[j]++;
                found = 1;
                break;
            }
        }
        if (!found) {
            values[unique_count] = val;
            counts[unique_count] = 1;
            unique_count++;
        }
    }
    
    int dominant_val = values[0];
    int dominant_count = counts[0];
    for (int i = 1; i < unique_count; i++) {
        if (counts[i] > dominant_count) {
            dominant_val = values[i];
            dominant_count = counts[i];
        }
    }
    
    int need_help = 2 * dominant_count - bad_count;
    if (need_help < 0) need_help = 0;
    
    int help_count = 0;
    for (int i = 0; i < n; i++) {
        int is_bad = 0;
        for (int j = 0; j < bad_count; j++) {
            if (bad_positions[j] == i) {
                is_bad = 1;
                break;
            }
        }
        if (!is_bad) {
            if (nums1[i] != dominant_val && nums2[i] != dominant_val) {
                help_positions[help_count++] = i;
            }
        }
    }
    
    if (help_count < need_help) {
        return -1;
    }
    
    long long total_cost = 0;
    for (int i = 0; i < bad_count; i++) {
        total_cost += bad_positions[i];
    }
    
    /* help_positions are already in ascending order since we iterate i=0..n-1 */
    for (int i = 0; i < need_help; i++) {
        total_cost += help_positions[i];
    }
    
    return total_cost;
}

int main() {
    char line1[1000000], line2[1000000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int nums1[100000], nums2[100000];
    int n1 = 0, n2 = 0;
    
    char* token = strtok(line1, "[], \t\n");
    while (token != NULL && n1 < 100000) {
        nums1[n1++] = atoi(token);
        token = strtok(NULL, "[], \t\n");
    }
    
    token = strtok(line2, "[], \t\n");
    while (token != NULL && n2 < 100000) {
        nums2[n2++] = atoi(token);
        token = strtok(NULL, "[], \t\n");
    }
    
    printf("%lld\n", minimumTotalCost(nums1, n1, nums2, n2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

We try all possible permutations of swaps (n!) and for each check validity (O(n))

✓ Linear Growth

Space Complexity

O(n)

Space for recursion stack and storing current permutation

⚡ Linearithmic Space

27.4K Views

Medium Frequency

~35 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

Brute Force (Try All Swaps) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler