K-Similar Strings - Practice Coding Problems

K-Similar Strings - Problem

Imagine you have two anagram strings and you want to transform one into the other by swapping characters. The K-Similar Strings problem asks you to find the minimum number of swaps needed to transform string s1 into string s2.

Two strings are called k-similar if you can make them identical by performing exactly k character swaps in the first string. Since both strings are anagrams, a solution is guaranteed to exist.

Goal: Given two anagram strings s1 and s2, return the smallest k for which s1 and s2 are k-similar.

Example: If s1 = "abc" and s2 = "bca", you need 2 swaps: first swap positions 0 and 1 to get "bac", then swap positions 1 and 2 to get "bca".

Input & Output

example_1.py — Basic Case

$ Input: s1 = "abc", s2 = "bca"

› Output: 2

💡 Note: We can transform 'abc' to 'bca' with 2 swaps: 'abc' → 'bac' (swap positions 0,1) → 'bca' (swap positions 1,2)

example_2.py — No Swaps Needed

$ Input: s1 = "ab", s2 = "ab"

› Output: 0

💡 Note: The strings are already identical, so no swaps are needed

example_3.py — Complex Case

$ Input: s1 = "aabbccdd", s2 = "ddccbbaa"

› Output: 4

💡 Note: This requires multiple strategic swaps to rearrange the characters optimally

Visualization

Tap to expand

Understanding the Visualization

Initial Arrangement

Start with current seating arrangement s1

Find Mismatch

Identify the first seat that doesn't match target arrangement s2

Try All Single Swaps

Generate all possible arrangements with one swap

Continue BFS

Repeat process level by level until target is reached

Key Takeaway

🎯 Key Insight: BFS explores states with minimum swaps first, guaranteeing that the first time we reach the target string, we've found the optimal solution with the fewest number of swaps needed.

Time & Space Complexity

Time Complexity

⏱️

O(n!)

In worst case, we might need to try all possible permutations of swaps

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and string manipulation

⚡ Linearithmic Space

Constraints

1 ≤ s1.length ≤ 20
s2.length == s1.length
s1 and s2 contain only lowercase English letters
s1 and s2 are anagrams of each other

Asked in

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

The optimal solution uses Breadth-First Search (BFS) to explore all possible swap combinations level by level. Since BFS explores states with fewer swaps first, the first time we reach the target string guarantees we've found the minimum number of swaps. The key insight is that we only need to consider swaps that move us closer to the target by fixing the first mismatched position.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS with Backtracking)	O(n!)	O(n)	Try all possible sequences of swaps using DFS
Breadth-First Search (Optimal)	O(n! * n)	O(n! * n)	Use BFS to find minimum number of swaps level by level

Brute Force (DFS with Backtracking) — Algorithm Steps

Start from the first position that doesn't match between s1 and s2
Find all positions in s1 that contain the character we need
Try swapping with each of these positions recursively
Keep track of the minimum number of swaps found
Backtrack by undoing swaps to try other possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with s1='abc' and s2='bca', compare first mismatched position

First Swap

Try swapping position 0 with position 1: 'abc' → 'bac'

Continue DFS

Recursively solve for remaining positions

Backtrack

If path doesn't lead to optimal solution, backtrack and try other swaps

Code -

solution.c — C

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

void swap_chars(char* s, int i, int j) {
    char temp = s[i];
    s[i] = s[j];
    s[j] = temp;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int dfs(char* s1, char* s2, int i, int len) {
    if (strcmp(s1, s2) == 0) return 0;
    
    // Skip positions that already match
    while (i < len && s1[i] == s2[i]) {
        i++;
    }
    
    if (i == len) return 0;
    
    int minSwaps = INT_MAX;
    
    // Try swapping position i with all positions j where s1[j] == s2[i]
    for (int j = i + 1; j < len; j++) {
        if (s1[j] == s2[i]) {
            // Perform swap
            swap_chars(s1, i, j);
            // Recursive call
            int swaps = 1 + dfs(s1, s2, i + 1, len);
            minSwaps = min(minSwaps, swaps);
            // Backtrack
            swap_chars(s1, i, j);
        }
    }
    
    return minSwaps;
}

int kSimilarity(char* s1, char* s2) {
    int len = strlen(s1);
    char* s1_copy = malloc((len + 1) * sizeof(char));
    strcpy(s1_copy, s1);
    int result = dfs(s1_copy, s2, 0, len);
    free(s1_copy);
    return result;
}

int main() {
    char s1[] = "abc";
    char s2[] = "bca";
    printf("%d\n", kSimilarity(s1, s2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

In worst case, we might need to try all possible permutations of swaps

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and string manipulation

⚡ Linearithmic Space

Constraints

1 ≤ s1.length ≤ 20
s2.length == s1.length
s1 and s2 contain only lowercase English letters
s1 and s2 are anagrams of each other

32.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (DFS with Backtracking) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler