字串变换（双向广搜)

已知有两个字串 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

共进行了三次变换，使得 AA 变换为 BB。

输入格式

输入格式如下：

A B
A1 B1
A2 B2
… …

第一行是两个给定的字符串 A 和 B。

接下来若干行，每行描述一组字串变换的规则。

所有字符串长度的上限为 20。

输出格式

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

输入样例：

abcd xyz
abc xu
ud y
y yz

输出样例：

3

考虑爆搜的话：最多一个字符串有20个字符，对应20个位置，每个位置可以转换成6个状态，最多转换十次，那么最多就是有120^10这么多种
由于我们知道BFS是一层一层搜索，所以对应的应该是指数级别的递增
但是如果我们是双向，从头和尾同时搜索，即从第一层和最后一层同时搜索，那么本来120^10就会变成2*120^5，大大减少
一般运用于最小步数模型，也就是按照状态转移
小技巧：扩展的时候，选择两头元素个数较少的先扩展

---

#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[], string b[])
{
    int d = da[q.front()];//标记队头元素的距离，因为我们只枚举距离相等的这一层
    while(q.size() && da[q.front()] == d)
    {
        auto 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;//如果说在b中已经找到了这个r,那么就说明连通了,距离就是这个
                    if(da.count(r)) continue;//如果说a中已经有了，就不用重复搜索了
                    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;//一个记录到A的距离，一个记录到B的距离
    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);//一个是从前往后，a的距离，b的距离，把a变成b
        else    t = extend(qb, db, da, b, a);//从后往前，b的距离，a的距离，把b变成a，规则倒着用
        
        if (t <= 10) return t;
        if ( ++ step == 10) return -1;//记录一下步数，如果搜索了十步还是没有找到解
        
    }
    return -1;
}

int main()
{
    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;
}