Minimum Swaps to Make Strings Equal

Minimum Swaps to Make Strings Equal - Problem

You are given two strings s1 and s2 of equal length consisting of letters 'x' and 'y' only.

Your task is to make these two strings equal to each other. You can swap any two characters that belong to different strings, which means: swap s1[i] and s2[j].

Return the minimum number of swaps required to make s1 and s2 equal, or return -1 if it is impossible to do so.

Input & Output

Example 1 — Equal xy mismatches

$ Input: s1 = "xx", s2 = "yy"

› Output: 1

💡 Note: Two xy mismatches at positions 0 and 1. Swap s1[0] with s2[1]: s1="yx", s2="yx". One swap makes them equal.

Example 2 — Mixed mismatch types

$ Input: s1 = "xy", s2 = "yx"

› Output: 2

💡 Note: One xy mismatch at pos 0, one yx mismatch at pos 1. Need 2 swaps: swap s1[0] with s1[1] via s2[0], then fix remaining.

Example 3 — Impossible case

$ Input: s1 = "xx", s2 = "xy"

› Output: -1

💡 Note: Only 1 mismatch (odd number). Cannot make strings equal since total x's and y's must be even.

Constraints

1 ≤ s1.length, s2.length ≤ 1000
s1.length == s2.length
s1[i] and s2[i] are either 'x' or 'y'

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The optimal approach counts mismatch patterns: xy (s1='x', s2='y') and yx (s1='y', s2='x'). If total mismatches is odd, return -1. Otherwise, use formula: (xy + 1) / 2 + (yx + 1) / 2. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Swaps

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

Generate all possible swap combinations recursively. For each mismatch position, try swapping with every other mismatch position and recursively solve the remaining problem.

Count Mismatches - Optimal

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

Count positions where strings differ. If s1[i]='x' and s2[i]='y', it's an xy mismatch. If s1[i]='y' and s2[i]='x', it's a yx mismatch. Two xy mismatches can be fixed with 1 swap, two yx mismatches need 1 swap, and one xy + one yx need 2 swaps.

Brute Force - Try All Swaps — Algorithm Steps

Find all mismatch positions
Try swapping each pair recursively
Return minimum swaps needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Mismatch

Identify positions where s1[i] ≠ s2[i]

Try Swaps

Recursively try all swap combinations

Return Min

Return minimum swaps found

Code -

solution.c — C

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

int solution(char* s1, char* s2) {
    int n = strlen(s1);
    
    int xy_count = 0;  // s1[i] = 'x', s2[i] = 'y'
    int yx_count = 0;  // s1[i] = 'y', s2[i] = 'x'
    
    for (int i = 0; i < n; i++) {
        if (s1[i] == 'x' && s2[i] == 'y') {
            xy_count += 1;
        } else if (s1[i] == 'y' && s2[i] == 'x') {
            yx_count += 1;
        }
    }
    
    // If total mismatches is odd, impossible to fix
    if ((xy_count + yx_count) % 2 == 1) {
        return -1;
    }
    
    // Each pair of same-type mismatches needs 1 swap
    // Each xy + yx pair needs 2 swaps
    return (xy_count + 1) / 2 + (yx_count + 1) / 2;
}

int main() {
    char s1[1001], s2[1001];
    fgets(s1, sizeof(s1), stdin);
    s1[strcspn(s1, "\n")] = 0;
    fgets(s2, sizeof(s2), stdin);
    s2[strcspn(s2, "\n")] = 0;
    
    int result = solution(s1, s2);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Recursive branching tries all possible swap combinations exponentially

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels

⚡ Linearithmic Space

23.4K Views

Medium Frequency

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