854. K-Similar Strings

问题：

给定一个字符串A，每次交换其中两个字符，

最后使得到字符串B，求最少交换次数。

Example 1:
Input: A = "ab", B = "ba"
Output: 1

Example 2:
Input: A = "abc", B = "bca"
Output: 2

Example 3:
Input: A = "abac", B = "baca"
Output: 2

Example 4:
Input: A = "aabc", B = "abca"
Output: 2

Note:
1 <= A.length == B.length <= 20
A and B contain only lowercase letters from the set {'a', 'b', 'c', 'd', 'e', 'f'}

　　

解法：BFS

状态：每次交换后得到的字符串。

使用unordered_set来避免重复得到的字符串。

最终要求的交换次数，即为queue的展开层数。

本题中，重点：剪枝

对下一个交换的字符 i，j 的选择：

我们目的是最终找到字符串B

那么尽量向B靠近的选择交换。

• 首先确定 i：找到当前字符串cur和B不一致的字符。

 while(cur[i]==B[i]) i++;

• 然后确定 j：j 从 i+1 开始，直到字符串结尾n
  • 其中，若要交换的 cur[j] -> i 却 != B[i]，就没有靠近B去交换，那么不选择这种交换。
  • 另外，若要交换的两个字符 i 和 j 相同，那么交换没意义，也不选择这种交换。

if(cur[j]!=B[i] || cur[i]==cur[j]) continue;

代码参考：

class Solution {
public:
    void getidx(int mask, vector<int>& idx, int n) {
        idx.clear();
        for(int k=0; k<n; k++) {
            if((mask>>k)&1) idx.push_back(k);
            if(idx.size()==2) return;
        }
        return;
    }
    int kSimilarity(string A, string B) {
        int level = 0;
        int n = A.length();
        queue<string> q;
        unordered_set<string> visited;
        q.push(A);
        visited.insert(A);
        string cur, next;
        while(!q.empty()) {
            int sz = q.size();
            for(int k=0; k<sz; k++) {
                cur = q.front();
                q.pop();
                if(cur == B) return level;
                int i = 0;
                while(cur[i]==B[i]) i++;
                for(int j=i+1; j<n; j++) {
                    if(cur[j]!=B[i] || cur[i]==cur[j]) continue;
                    //only swap j which == target j
                    //can't swap i==j　(Useless)
                    next = cur;
                    swap(next[i], next[j]);
                    if(visited.insert(next).second) {
                        q.push(next);
                    }
                }
            }
            level++;
        }
        return -1;
    }
};