NOIP2002 字串变换题解（双向搜索）

65. [NOIP2002] 字串变换

时间限制：1 s   内存限制：128 MB

[问题描述]

已知有两个字串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$  |->变换规则

... ... /

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

[输出]

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

[输入样例]

abcd xyz
abc xu
ud y
y yz

[输出样例]

3
　　在这里膜拜一下wq大佬，强行bfs藐视数据，我就比较惨了，打了好几次，正着搜反着搜都会T某个点，这就比较尴尬了，于是乎，我们引进了双向搜索这个概念。
　　我们可以把宽搜想像为一棵树，为了方便计算，我们暂定它为二叉树好了，如果我要搜10层，我单项搜索，会有2047个节点，但如果我双向搜索，就只有63+63==126个节点了，由此可见，双向可以说是完爆单向的，何况这只是二叉树。
　　于是这道题在双向搜索的前提下就无比简单了，我们把A,B分别塞进两个队列，同时广搜，直到两者相遇。至于修改操作吗，string就可以搞定了。
　　

 #include<iostream>
 #include<cstdlib>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<map>
 #include<queue>
 #include<string>
 #include<cmath>
 using namespace std;
 string a,b;
 string A[],B[];
 struct st{
     string x;
     int js;
 };
 int js;
 queue<st> q1;
 bool yx;
 int p=,q=;
 unsigned long long xp[];
 int fw[][];
 bool get_hash(st x,int be){
     unsigned long long has=;
     for(int i=x.x.length()-;i>=;i--)
     {
         has=has*p+int(x.x[i]);
     }
     has%=q;
     if(fw[be][has])
         return ;
     fw[be][has]=x.js;
     if(fw[be^][has])
     {
         printf("%d\n",x.js+fw[be^][has]);
         exit();
     }
         return ;
 }
 queue<st> q2;
 void bfs(){
     while(!q1.empty()&&!q2.empty())
     {
         st aa=q1.front();
         q1.pop();
         if(aa.js>)
         {
             yx=;
             printf("NO ANSWER!\n");
             return;
         }
         for(int i=;i<=js;i++)
         {
             int la=-;
             for(int j=;j<=aa.x.length();j++)
             {
                 long long t=aa.x.find(A[i],j);
                 if(t>=&&t<=&&t!=la)
                 {
                     la=t;
                     j=la-;
                     st c;
                     c.x=aa.x;
                     c.x.replace(t,A[i].length(),B[i]);
                     c.js=aa.js+;
                     if(c.x.length()<=&&!get_hash(c,)&&c.js<=)
                     {
                         q1.push(c);
                     }
                 }
             }
         }
         st bb=q2.front();
         q2.pop();
         if(bb.js>)
         {
             yx=;
             printf("NO ANSWER!\n");
             return;
         }
         for(int i=;i<=js;i++)
         {
             int la=-;
             for(int j=;j<=bb.x.length();j++)
             {
                 long long t=bb.x.find(B[i],j);
                 if(t>=&&t<=&&t!=la)
                 {
                     la=t;
                     j=la-;
                     st c;
                     c.x=bb.x;
                     c.x.replace(t,B[i].length(),A[i]);
                     c.js=bb.js+;
                     if(c.x.length()<=&&!get_hash(c,)&&c.js<=)
                     {
                         q2.push(c);
                     }
                 }
             }
         }
     }
 }
 int main(){
     cin>>a>>b;
     js=;
     while(cin>>A[js]>>B[js])
     {
         js++;
     }
     js--;
     st xx;
     xx.x=a;
     xx.js=;
     q1.push(xx);
     get_hash(xx,);
     st yy;
     yy.x=b;
     yy.js=;
     q2.push(yy);
     get_hash(yy,);
     xp[]=;
     for(int i=;i<=;i++)
     {
         xp[i]=xp[i-]*p;
     }
     bfs();
     if(!yx)
         printf("NO ANSWER!\n");
     //while(1);
     return ;
 }