【ACWing】190. String conversion

Subject address:

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

There are two known strings $A$，$B$ and a set of string conversion rules (at most$6$ rules):
$A_1\to B_1$
$A_2\to B_2$
$\dots$
The meaning of the rule is: in$A$ in substring$A_1$Can be converted to $B_1$、$A_2$Can be transformed into $B_2...$ .
For example: theA＝abcd B＝xyz
conversion rule is:
abc → xu, ud → y, y → yz
then at this time,$A$ can be transformed intoBBthrough a series of transformations$B$ , the transformation process is:
"abcd → xud → xy → xyz"
a total of three transformations are carried out, so that$A\; is$ converted to$B$。

Input format: The
input format is as follows:
$AB$
$A_1{B}_1$
$A_2{B}_2$
$\dots \dots The$
first line is two given strings$A$ and$B$ . The next few lines, each line describes a set of string transformation rules. The maximum length of all strings is$20$。

Output format:
if in $.\; 10$ Step (containing$10$ step) can within$A\; is$ converted to$B$ , then output the least number of transformation steps; otherwise, outputNO ANSWER!.

Two-way BFS can be used. Every time you consider dequeuing, you can expand the queue with fewer elements first. code show as below:

#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;
}

Time complexity $O(V+E)$。