字符变换双端队列

自己的笔记
用题目了解

已知有两个字串 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 B
A1 B1
A2 B2
… …

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

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

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

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

思路就是双端队列，直接看代码

#include<bits/stdc++.h>
using namespace std;
const int N = 6;
int n;
string a[N],b[N];
// 扩展函数
// 参数：扩展的队列，到起点的距离，到终点的距离，规则，规则
//返回值：满足条件的最小步数
int extend(queue<string>& q, unordered_map<string,int>& da, unordered_map<string, int>& db,
        string a[], string b[]){
    // 取出队头元素
    string t = q.front();
    q.pop();

    for(int i = 0; i < t.size(); i ++)  // t从哪里开始扩展
        for(int j = 0; j < n; j ++) // 枚举规则
            //如果t这个字符串的一段= 规则，比如= xyz，才可以替换
            if(t.substr(i, a[j].size()) == a[j]){
                // 变换之后的结果state:前面不变的部分+ 变化的部分 + 后面不变的部分
                // 比如abcd ，根据规则abc--> xu，变成 xud，这里的state就是xud
                string state = t.substr(0,i) +b[j] + t.substr(i + a[j].size());
                // state状态是否落到b里面去，两个方向会师，返回最小步数
                if(db.count(state)) return da[t] + 1 + db[state];
                // 如果该状态之前已扩展过，
                if(da.count(state)) continue;
                da[state] = da[t] + 1;
                q.push(state);
            }
    return 11;

}
// 从起点和终点来做bfs
int bfs(string A, string B){
    queue<string> qa, qb; // 两个方向的队列
    //每个状态到起点的距离da（哈希表），每个状态到终点的距离db哈希表
    unordered_map<string, int> da, db; 
    // qa从起点开始搜，qb从终点开始搜
    qa.push(A), da[A] = 0; // 起点A到起点的距离为0
    qb.push(B), db[B] = 0; // 终点B到终点B的距离为0

    // qa和qb都有值，说明可以扩展过来，否则说明是不相交的
    while(qa.size() && qb.size()){
        int t; // 记录最小步数
        // 哪个方向的队列的长度更小一些，空间更小一些，从该方向开始扩展，
        // 时间复杂度比较平滑,否则有1个点会超时
        if(qa.size() <= qb.size()) 
            t = extend(qa, da, db, a, b);
        else t = extend(qb, db, da, b, a);
        // 如果最小步数在10步以内

        if( t <= 10) return t;
    }

    return 11; // 如果不连通或者最小步数>10，则返回大于10的数

}

int main(){
    string A, B;
    cin >> A >> B;
    // 读入扩展规则，分别存在a数组和b数组
    while( cin >> a[n] >> b[n]) n ++;
    int step = bfs(A,B);
    if(step > 10) puts("NO ANSWER!");
    else cout << step << endl;
}