Minimize Hamming Distance After Swap Operations

Minimize Hamming Distance After Swap Operations - Problem

Imagine you have two arrays of the same length - source and target - and you want to make them as similar as possible! 🎯

You're given a set of allowed swap operations that let you swap elements at specific pairs of indices in the source array. The catch? You can perform these swaps multiple times and in any order!

Your goal is to minimize the Hamming distance - the number of positions where the arrays differ. Think of it as a puzzle where you need to rearrange pieces optimally to match a target pattern.

Example: If source = [1,2,3,4] and target = [2,1,4,5], and you can swap positions (0,1) and (2,3), you could swap elements at indices 0 and 1 to get [2,1,3,4], reducing differences from 4 positions to just 2!

Input & Output

example_1.py — Basic Swapping

$ Input: source = [1,2,3,4], target = [2,1,4,5], allowedSwaps = [[0,1],[2,3]]

› Output: 1

💡 Note: We can swap indices (0,1) to get [2,1,3,4]. This matches target at positions 0,1. Position 2 differs (3≠4) and position 3 differs (4≠5), but we can swap (2,3) to get [2,1,4,3]. Now positions 0,1,2 match but position 3 still differs (3≠5). Final distance is 1.

example_2.py — No Swaps Needed

$ Input: source = [1,2,3,4], target = [1,2,3,4], allowedSwaps = [[0,1],[2,3]]

› Output: 0

💡 Note: Arrays are already identical, so Hamming distance is 0. No swaps needed.

example_3.py — Complete Mismatch

$ Input: source = [5,6,7,8], target = [1,2,3,4], allowedSwaps = [[0,1],[2,3]]

› Output: 4

💡 Note: No element in source matches any element in target, regardless of swaps. All 4 positions will differ, so minimum Hamming distance is 4.

Visualization

Tap to expand

Understanding the Visualization

Build Groups

Use Union-Find to identify which indices can reach each other through swaps

Analyze Each Group

For each connected component, count how many of each value appear in source and target

Optimize Matching

Within each group, match as many source values with target values as possible

Calculate Result

Sum up all possible matches and subtract from total length to get minimum distance

Key Takeaway

🎯 Key Insight: By identifying connected components through Union-Find, we can optimally arrange elements within each group independently, maximizing matches and minimizing the Hamming distance.

Time & Space Complexity

Time Complexity

⏱️

O(2^m × n)

Where m is number of allowed swaps and n is array length. We explore exponentially many swap combinations.

✓ Linear Growth

Space Complexity

O(n)

Space for storing current array state and recursion stack

⚡ Linearithmic Space

Constraints

n == source.length == target.length
1 ≤ n ≤ 10⁵
1 ≤ source[i], target[i] ≤ 10⁵
0 ≤ allowedSwaps.length ≤ 10⁵
allowedSwaps[i].length == 2
0 ≤ a_i, b_i ≤ n - 1
a_i ≠ b_i

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses Union-Find to identify connected components of swappable indices. Within each component, we count frequencies of source and target elements, then calculate the maximum possible matches. The minimum Hamming distance equals total elements minus maximum matches. Time complexity is O(n α(n)) where α is the inverse Ackermann function.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Swaps)	O(2^m × n)	O(n)	Try all possible combinations of allowed swaps
Union-Find (Optimal)	O(n α(n))	O(n)	Group swappable elements, then optimize each group independently

Brute Force (Try All Swaps) — Algorithm Steps

Start with the original source array
Generate all possible swap sequences using backtracking
For each sequence, apply swaps and calculate Hamming distance
Keep track of the minimum distance found
Return the minimum distance across all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original source array

Try First Swap

Apply first allowed swap and calculate distance

Explore Further

From current state, try more swaps recursively

Backtrack

Undo swaps and try different combinations

Find Minimum

Track the minimum Hamming distance found

Code -

solution.c — C

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

int minDistance;

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

void swap(int* arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

void backtrack(int* currSource, int* target, int n, int allowedSwaps[][2], 
               int swapCount, int* usedSwaps) {
    int distance = hammingDistance(currSource, target, n);
    if (distance < minDistance) minDistance = distance;
    
    for (int i = 0; i < swapCount; i++) {
        if (!usedSwaps[i]) {
            int a = allowedSwaps[i][0], b = allowedSwaps[i][1];
            // Try this swap
            swap(currSource, a, b);
            usedSwaps[i] = 1;
            backtrack(currSource, target, n, allowedSwaps, swapCount, usedSwaps);
            // Backtrack
            swap(currSource, a, b);
            usedSwaps[i] = 0;
        }
    }
}

int minimumHammingDistance(int* source, int* target, int n, int allowedSwaps[][2], int swapCount) {
    minDistance = n;
    int* sourceCopy = (int*)malloc(n * sizeof(int));
    int* usedSwaps = (int*)calloc(swapCount, sizeof(int));
    memcpy(sourceCopy, source, n * sizeof(int));
    
    backtrack(sourceCopy, target, n, allowedSwaps, swapCount, usedSwaps);
    
    free(sourceCopy);
    free(usedSwaps);
    return minDistance;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^m × n)

Where m is number of allowed swaps and n is array length. We explore exponentially many swap combinations.

✓ Linear Growth

Space Complexity

O(n)

Space for storing current array state and recursion stack

⚡ Linearithmic Space

Constraints

n == source.length == target.length
1 ≤ n ≤ 10⁵
1 ≤ source[i], target[i] ≤ 10⁵
0 ≤ allowedSwaps.length ≤ 10⁵
allowedSwaps[i].length == 2
0 ≤ a_i, b_i ≤ n - 1
a_i ≠ b_i

23.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Swaps) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler