字串变换 (2002 年NOIP全国联赛提高组)

　　　　　　　　　　一道看似非常水的题

　　大意 ：将一个字串 经过几种变换规则变为给定的另一个子串 ，求最小操作数。

　　code[vs] 传送门

　　洛谷传送门

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

　　

　　思路：从前从后双向BFS 不加限制 若递归次数等于10次仍未找到答案时，输出NO ANSWER 。其他的若替换完后 从 前端BFS的串 在从后端BFS出现过，则此时递归次数乘2减一即为答案， 　　从后端BFS的情况同上。   具体实现，就按照题意来，依次扫描变换规则，进行替换，替换完的字串加入队列。

　　双向BFS

#include <iostream>
#include <cstring>
#include <map>
#include <cstdio>
using namespace std;
const int Max = ;
string A, B;
string s_change [][], Front[Max], Back[Max];
int Limit = , head_Front = , tail_Front = , tail_Back = , head_Back = , tot = ;
map < string , int > Map_Front;
map < string , int > Map_Back;
void BFS ()
{
    tot++;  //记录递归次数
    string s, s_replace;  // s是  变换后的字串 ，s_replace 是当前需变换的字串
    int head, tail;
    head = head_Front; //调整指针
    tail = tail_Front;
    for (int i = head; i <= tail; i++)
        for (int j = ; j <= Limit; j++)  //变换种数 ，变为不同的替换规则
        {
            int change_Front = ;
            while (change_Front != -)   //每个字串中可以替换的字串不止一个
            {
                s_replace = Front [i];  //取出当前需被变换的字串
                change_Front = s_replace.find (s_change [j][], change_Front );   //查找变换规则 ，change_Front是 当前规则 出现的位置
                if (change_Front >= )
                {
                    s = s_replace.replace (change_Front, s_change [j][].length(), s_change [j][]);  //进行替换， s存的是替换完的字串
                    if (Map_Front [s] == )  //剪枝 ，若该字串出现过，则不进入队列
                    {
                        if (Map_Back [s] != )    //如果能在中间遇到，就直接输出答案
                        {
                            cout << tot *  - ;
                            return ;
                        }
                        Front [++tail_Front] = s;  //加入队列
                        Map_Front [s] = ;    //标记为出现过
                    }
                }
                if (change_Front != -) change_Front += s_change[j][].length();   //寻找下一个字串
            }
        }
    head_Front = tail + ;        //同上 ，不过是从后面进行BFS
     head = head_Back;
    tail = tail_Back;
    for (int i = head; i <= tail; ++i)
        for (int j = ; j <= Limit; ++j)
        {
            int change_Back = ;
            while (change_Back != -)
            {
                s_replace = Back[i];
                change_Back = s_replace.find (s_change[j][], change_Back);
                if (change_Back >= )
                {
                    s = s_replace.replace (change_Back, s_change [j][].length(), s_change[j][]);
                    if (Map_Back[s] == )
                    {
                        if(Map_Front[s] != )
                        {
                            cout << tot * ;
                            return ;
                        }
                        Back[++tail_Back] = s;
                        Map_Back[s] = ;
                    }
                }
                if (change_Back != -) change_Back = change_Back + s_change [j][].length();
            }
        }
    head_Back = tail + ;
    if (tot == )    //以十次为限，若十次后仍未找到，则输出NO ANSWER
    {
        cout << "NO ANSWER!";
        return;
    }
    BFS ();
}
int main()
{
    ios::sync_with_stdio (false);
    cin >> A >> B;
    while (cin >> s_change[Limit][] >> s_change [Limit][]) Limit++;
    Limit--;  // 替换的组数
    Map_Front [A] = ;  //用 map 记录
    Map_Back [B] = ;
    Front [] = A;  //加入队列
    Back [] = B;
    BFS ();
    return ;
}

　　注意：此题属于那种看似很水，但是实现有难度的题。。