【ACWing】 190. Conversión de cadenas

Dirección del asunto:

https://www.acwing.com/problem/content/description/192/

Hay dos cadenas conocidas $A$ ,$B$ y un conjunto de reglas de conversión de cadenas (como máximo$6$ reglas):
$A_1\to B_1$
$A_2\to B_2$
$...$
El significado de la regla es: en$A$ en la subcadena$A_1$Se puede convertir a $B_1$、$A_2$Se puede transformar en $B_2...$ .
Por ejemplo: laA＝abcd B＝xyz
regla de conversión es:
abc → xu, ud → y, y → yz
entonces, en este momento,$A$ se puede transformar enBBmediante una serie de transformaciones$B$ , el proceso de transformación es:
"abcd → xud → xy → xyz"
se realizan un total de tres transformaciones, de modo que$A\; se$ convierte en$B$ .

Formato de entrada: El
formato de entrada es el siguiente:
$AB$
$A_1{B}_1$
$A_2{B}_2$
$...\dots \; La$
primera línea son dos cadenas dadas$A$ y$B$ . Las siguientes líneas, cada línea, describe un conjunto de reglas de transformación de cadenas. La longitud máxima de todas las cuerdas es$20$。

Formato de salida:
si en $.10$ Paso (contiene$10$ paso) puede dentro de$A\; se$ convierte en$B$ , luego genere el menor número de pasos de transformación; de lo contrario, genereNO ANSWER!.

Se puede utilizar BFS bidireccional. Cada vez que considere quitar la cola, puede expandir la cola con menos elementos primero. el código se muestra a continuación:

#include <iostream>
#include <queue>
#include <unordered_map>
using namespace std;

const int N = 6;

int n;
string a[N], b[N];
int res;

// 返回从q的队头拓展出一步是否会和和另一个方向“会师”
bool extend(queue<string>& q, unordered_map<string, int>& da, unordered_map<string, int>& db, string a[], string b[]) {
    
    
    string t = q.front();
    q.pop();
	
	// 枚举从t的哪个位置开始变换
    for (int i = 0; i < t.size(); i++)
    	// 枚举是否能变换，当能变换的时候，求一下能变为谁
        for (int j = 0; j < n; j++)
            if (t.substr(i, a[j].size()) == a[j]) {
    
    
                string ne = t.substr(0, i) + b[j] + t.substr(i + a[j].size());
                // 如果之前走到过这个状态，则略过
                if (da.count(ne)) continue;
                // 否则更新一下距离
                da[ne] = da[t] + 1;
				
				// 如果与另一边会师了，则记录一下答案，并返回true
                if (db.count(ne)) {
    
    
                    res = da[ne] + db[ne];
                    return true;
                }

                q.push(ne);
            }

    return false;
}

int bfs(string A, string B) {
    
    
    unordered_map<string, int> da, db;
    da[A] = db[B] = 0;

    queue<string> qa, qb;
    qa.push(A), qb.push(B);

    while (qa.size() && qb.size()) {
    
    
        if (qa.size() <= qb.size()) {
    
    
            if (extend(qa, da, db, a, b)) return res;
        } else if (extend(qb, db, da, b, a)) return res;
    }

    return 11;
}

int main() {
    
    
    string A, B;
    cin >> A >> B;

    while (cin >> a[n] >> b[n]) n++;

    int res = bfs(A, B);
    if (res > 10) cout << "NO ANSWER!" << endl;
    else cout << res << endl;

    return 0;
}

Complejidad temporal $O(V+E)$。