K-Similar Strings

K-Similar Strings - Problem

Strings s1 and s2 are k-similar (for some non-negative integer k) if we can swap the positions of two letters in s1 exactly k times so that the resulting string equals s2.

Given two anagrams s1 and s2, return the smallest k for which s1 and s2 are k-similar.

Input & Output

Example 1 — Basic Swap

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

› Output: 1

💡 Note: Swap s1[0] and s1[1]: "ab" → "ba". One swap needed.

Example 2 — No Swaps Needed

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

› Output: 0

💡 Note: Strings are already identical, no swaps needed.

Example 3 — Multiple Swaps

$ Input: s1 = "abcd", s2 = "cdab"

› Output: 2

💡 Note: First swap(0,2): "abcd" → "cbad", then swap(1,3): "cbad" → "cdab".

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

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 32 a Amazon 28

The key insight is to use BFS to explore string states level by level, guaranteeing minimum swaps. The optimized approach only considers swaps that fix incorrect positions. Best approach is Optimized BFS with Time: O(n! × n), Space: O(n!).

Common Approaches

✓ BFS - Breadth-First Search

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

Treat each string configuration as a state and use BFS to explore all possible swaps. Since BFS explores states level by level, the first time we reach the target guarantees minimum swaps.

Brute Force with Backtracking

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

Generate all possible swap operations and recursively try each one, keeping track of the minimum swaps needed. This explores the entire solution space but is extremely inefficient.

Optimized BFS with Early Pruning

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

Enhanced BFS that only considers swaps involving positions that are incorrect. This reduces the search space significantly by focusing only on meaningful swaps that can lead to the solution.

BFS - Breadth-First Search — Algorithm Steps

Step 1: Start with s1 in queue, mark as visited
Step 2: For each state, try all valid swaps
Step 3: Add new states to queue if not visited
Step 4: Return level when target is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Start with initial string s1

Level 1

Generate all possible 1-swap states

Found

First occurrence of target guarantees minimum

Code -

solution.c — C

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

#define MAX_STATES 10000

typedef struct {
    char str[21];
    int swaps;
} State;

int solution(char* s1, char* s2) {
    int len = strlen(s1);
    if (strcmp(s1, s2) == 0) return 0;
    
    State queue[MAX_STATES];
    char visited[MAX_STATES][21];
    int front = 0, rear = 0, visitedCount = 0;
    
    strcpy(queue[rear].str, s1);
    queue[rear].swaps = 0;
    rear++;
    strcpy(visited[visitedCount], s1);
    visitedCount++;
    
    while (front < rear) {
        State current = queue[front++];
        
        // Find first position where current != s2
        int i = 0;
        while (i < len && current.str[i] == s2[i]) {
            i++;
        }
        
        if (i == len) {
            return current.swaps;
        }
        
        // Try all swaps from position i
        for (int j = i + 1; j < len; j++) {
            if (current.str[j] == s2[i]) {
                // Perform swap
                char temp = current.str[i];
                current.str[i] = current.str[j];
                current.str[j] = temp;
                
                if (strcmp(current.str, s2) == 0) {
                    return current.swaps + 1;
                }
                
                // Check if visited
                int isVisited = 0;
                for (int k = 0; k < visitedCount; k++) {
                    if (strcmp(visited[k], current.str) == 0) {
                        isVisited = 1;
                        break;
                    }
                }
                
                if (!isVisited && rear < MAX_STATES) {
                    strcpy(visited[visitedCount], current.str);
                    visitedCount++;
                    strcpy(queue[rear].str, current.str);
                    queue[rear].swaps = current.swaps + 1;
                    rear++;
                }
                
                // Undo swap
                current.str[j] = current.str[i];
                current.str[i] = temp;
            }
        }
    }
    
    return 0;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n! × n²)

At most n! possible string states, each requiring O(n²) swaps to generate

⚠ Quadratic Growth

Space Complexity

O(n!)

Visited set stores up to n! different string configurations

⚠ Quadratic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

856 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

BFS - Breadth-First Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler