K-Similar Strings solution and explanation

from collections import deque

def kSimilarity(s1, s2):
    def neighbors(s):
        for i in range(len(s)):
            if s[i] != s2[i]:
                break
        for j in range(i + 1, len(s)):
            if s[j] == s2[i]:
                yield s[:i] + s[j] + s[i + 1:j] + s[i] + s[j + 1:]

    queue = deque([(s1, 0)])
    visited = {s1}
    while queue:
        s, k = queue.popleft()
        if s == s2:
            return k
        for nei in neighbors(s):
            if nei not in visited:
                visited.add(nei)
                queue.append((nei, k + 1))

import java.util.*;

class Solution {
    public int kSimilarity(String s1, String s2) {
        Queue<String> queue = new LinkedList<>();
        Set<String> visited = new HashSet<>();
        queue.offer(s1);
        visited.add(s1);
        int swaps = 0;
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                String current = queue.poll();
                if (current.equals(s2)) {
                    return swaps;
                }
                for (String next: neighbors(current, s2)) {
                    if (!visited.contains(next)) {
                        visited.add(next);
                        queue.offer(next);
                    }
                }
            }
            swaps++;
        }
        return -1;
    }

    private List<String> neighbors(String s1, String s2) {
        List<String> result = new ArrayList<>();
        char[] arr = s1.toCharArray();
        int i = 0;
        while (arr[i] == s2.charAt(i)) i++;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] == s2.charAt(i) && arr[j] != s2.charAt(j)) {
                swap(arr, i, j);
                result.add(new String(arr));
                swap(arr, i, j);  // revert
            }
        }
        return result;
    }

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

#include <vector>
#include <string>
#include <algorithm>

class Solution {
public:
    int kSimilarity(std::string s1, std::string s2) {
        return dfs(s1, s2, 0);
    }

private:
    int dfs(std::string& s1, std::string& s2, int start) {
        if (start == s1.size()) return 0;
        if (s1 == s2) return 0;
        if (s1[start] == s2[start])
            return dfs(s1, s2, start + 1);
        int minSwaps = INT_MAX;
        for (int i = start + 1; i < s1.size(); ++i) {
            if (s1[i] == s2[start] && s1[i] != s2[i]) {
                std::swap(s1[start], s1[i]);
                minSwaps = std::min(minSwaps, 1 + dfs(s1, s2, start + 1));
                std::swap(s1[start], s1[i]);  // revert
            }
        }
        return minSwaps;
    }
};

using System;
using System.Collections.Generic;

public class Solution {
    public int KSimilarity(string s1, string s2) {
        return DFS(s1.ToCharArray(), s2.ToCharArray(), 0);
    }

    private int DFS(char[] s1, char[] s2, int start) {
        if (start == s1.Length) return 0;
        if (new string(s1) == new string(s2)) return 0;
        if (s1[start] == s2[start])
            return DFS(s1, s2, start + 1);
        int minSwaps = int.MaxValue;
        for (int i = start + 1; i < s1.Length; i++) {
            if (s1[i] == s2[start] && s1[i] != s2[i]) {
                Swap(s1, start, i);
                minSwaps = Math.Min(minSwaps, 1 + DFS(s1, s2, start + 1));
                Swap(s1, start, i);  // revert
            }
        }
        return minSwaps;
    }

    private void Swap(char[] arr, int i, int j) {
        char temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

func kSimilarity(s1 string, s2 string) int {
	next := func(s string) []string {
		i := 0
		res := []string{}
		for ; s[i] == s2[i]; i++ {
		}
		for j := i + 1; j < len(s1); j++ {
			if s[j] == s2[i] && s[j] != s2[j] {
				res = append(res, s[:i]+string(s[j])+s[i+1:j]+string(s[i])+s[j+1:])
			}
		}
		return res
	}

	q := []string{s1}
	vis := map[string]bool{s1: true}
	ans := 0
	for {
		for i := len(q); i > 0; i-- {
			s := q[0]
			q = q[1:]
			if s == s2 {
				return ans
			}
			for _, nxt := range next(s) {
				if !vis[nxt] {
					vis[nxt] = true
					q = append(q, nxt)
				}
			}
		}
		ans++
	}
}