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: 1

💡 Note: We swap indices 1 and 2 in nums1. Cost = 1 + 2 = 3. But we can swap indices 1 and 0 with cost = 1, making nums1 = [2,1,3,4]. Now nums1[i] != nums2[i] for all i.

example_2.py — No Solution

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

› Output: -1

💡 Note: It's impossible to make nums1[i] != nums2[i] for all i. Value 2 appears too frequently in bad positions.

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

Understanding the Visualization

Identify Conflicts

Mark all positions where person matches their unlucky seat

Count Problem People

Some people appear in multiple unlucky positions - they need special attention

Calculate Help Needed

If one person dominates conflicts, we need extra positions to resolve

Minimize Cost

Use positions with lowest indices (cheapest swaps) to resolve all conflicts

Key Takeaway

🎯 Key Insight: The greedy approach works because we must include all conflicting positions in swaps. The challenge is handling cases where one value dominates - requiring strategic use of additional positions to resolve conflicts optimally.

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

Approach	Time	Space	Notes
✓ Brute Force (Try All Swaps)	O(n! × n)	O(n)	Try all possible combinations of swaps to find minimum cost solution
Greedy with Hash Counting (Optimal)	O(n)	O(n)	Use greedy strategy to identify conflicts and fix them optimally

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 <limits.h>

int isValid(int* arr1, int* arr2, int n) {
    for (int i = 0; i < n; i++) {
        if (arr1[i] == arr2[i]) return 0;
    }
    return 1;
}

void backtrack(int* arr, int* nums2, int n, int currentCost, int* minCost, int* found) {
    if (isValid(arr, nums2, n)) {
        if (currentCost < *minCost) {
            *minCost = currentCost;
        }
        *found = 1;
        return;
    }
    
    if (currentCost >= *minCost) return;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            
            backtrack(arr, nums2, n, currentCost + i + j, minCost, found);
            
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
}

long long minimumTotalCost(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    if (isValid(nums1, nums2, nums1Size)) return 0;
    
    int* nums1Copy = (int*)malloc(nums1Size * sizeof(int));
    for (int i = 0; i < nums1Size; i++) {
        nums1Copy[i] = nums1[i];
    }
    
    int minCost = INT_MAX;
    int found = 0;
    
    backtrack(nums1Copy, nums2, nums1Size, 0, &minCost, &found);
    
    free(nums1Copy);
    return found && minCost != INT_MAX ? minCost : -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

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

⚠ Quadratic 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