字符变换

已知有两个字串 A, B及一组字串变换的规则（至多 6 个规则）:
A1→B1
A2→B2
…
规则的含义为：在 A 中的子串 A1中 可以变换为 B1、A2可以变换为 B2…。

例如：A
＝abcd B
＝xyz

变换规则为：

abc →xu ud → y y →yz
则此时，A 可以经过一系列的变换变为 B，其变换的过程为：
abcd → xud →xy →xyz
共进行了三次变换，使得 A变换为 B。

注意，一次变换只能变换一个子串，例如 A＝aa B＝bb
变换规则为：
a → b
此时，不能将两个 a 在一步中全部转换为 b，而应当分两步完成。

输入格式
输入格式如下：
A B
A1 B1
A2 B2
… …
第一行是两个给定的字符串 A 和 B
。
接下来若干行，每行描述一组字串变换的规则。
所有字符串长度的上限为 20。

输出格式
若在 10 步（包含 10步）以内能将 A变换为 B，则输出最少的变换步数；否则输出 NO ANSWER!。

输入样例：
abcd xyz
abc xu
ud y
y yz
输出样例：
3

Solutions

读取两个字符串 A 和 B，后跟字符串对 a[i] 和 b[i]. 的列表，其中每个转换步骤都涉及将一个字符串的最后一个字符更改为另一个字符串的第一个字符。

程序的主函数首先使用 >> 运算符读入两个输入字符串 A 和 B，循环继续，直到不再有输入可读，此时退出。

程序读入输入数据后，调用bfs函数进行广度优先搜索，bfs函数初始化两个队列qa和qb，分别用于存储A和B可以变换的字符串的索引，它还初始化两个数组 da 和 db，分别用于存储从 A 和 B 到达每个字符串所需的最小转换次数。

然后，bfs 函数通过重复扩展较小大小的队列来执行广度优先搜索，直到其中一个队列为空或达到最大步数。可以从当前字符串进行转换，并更新最小步数如果找到更短的路径，则到达每个字符串所需的转换。
该函数接收一个字符串队列 q、两个无序映射 da 和 db，以及两个字符串数组 a 和 b。该函数返回一个整数，表示将一个字符串转换为另一个字符串所需的最小步骤数。

extend函数首先将变量d初始化为达到广度优先搜索当前级别所需的最小步数，广度优先搜索的下一个级别大于10。

在 while 循环内，该函数将第一个字符串 t 从队列中出列，并使用字符串对 a[i] 和 b[i] 考虑 t 的所有可能转换。t 中将 a[i] 与 b[i] 匹配的子字符串. 如果 r 已经在 db 映射中，则函数返回分别从 A 和 B 到达 t 和 r 所需的最小步数之和，加一 如果 r 已经在 da 映射中，则函数跳过转换。

最后，如果队列为空或者到达广度优先搜索的下一级所需的最小步数大于 10，则该函数返回 11。

总的来说，extend函数是解决字符串转换问题的广度优先搜索算法的关键组成部分。该函数有效地生成给定字符串的所有可能的转换，并更新从A到达每个转换后的字符串所需的最小步骤数。函数结构良好且易于理解，具有清晰的变量名称和注释，解释每个变量和操作的用途。

最后，main函数检查bfs函数的返回值，如果返回值为-1，则输出字符串“NO ANSWER!”，否则输出从A到达B所需的最少变换次数。

#include <bits/stdc++.h>

using namespace std;

const int N = 6;

int n;
string A, B;
string a[N], b[N];

int extend(queue<string>& q, unordered_map<string, int>& da, unordered_map<string, int>& db, string a[N], string b[N]) {
    int d = da[q.front()];
    while (q.size() && da[q.front()] == d) {
        string t = q.front();
        q.pop();
        for (int i = 0; i < n; i ++ ) {
            for (int j = 0; j < t.size(); j ++ ) {
                if (t.substr(j, a[i].size()) == a[i]) {
                    string r = t.substr(0, j) + b[i] + t.substr(j + a[i].size());
                    if (db.count(r)) return da[t] + db[r] + 1;
                    if (da.count(r)) continue;
                    da[r] = da[t] + 1;
                    q.push(r);
                }
            }
        }
    }
    return 11;
}

int bfs() {
    if (A == B) return 0;
    queue<string> qa, qb;
    unordered_map<string, int> da, db;
    qa.push(A), qb.push(B);
    da[A] = db[B] = 0;
    int step = 0;
    while (qa.size() && qb.size()) {
        int t;
        if (qa.size() < qb.size()) t = extend(qa, da, db, a, b);
        else t = extend(qb, db, da, b, a);
        if (t <= 10) return t;
        if (++ step == 10) return -1;
    }
    return -1;
}

int main() {
    cin.tie(nullptr);
    cout.tie(nullptr);
    ios::sync_with_stdio(false);
    cin >> A >> B;
    while (cin >> a[n] >> b[n]) n ++;
    int t = bfs();
    if (t == -1) puts("NO ANSWER!");
    else cout << t << endl;
    return 0;
}