Gym 100030F Magic Chains （BFS+HASH）

题目链接：http://codeforces.com/gym/100030/attachments

题目大意：

给定若干个长度一样的字符串，
从第一个字符串出发，每次操作可以改变一个字符，
问要变成最后一个字符串最少需要几次变换，
并且打印路径。

题目分析：

 常规的搜索题，一开始很容易想到用MAP结构，
但会被超时，如何从若干个字符串中找到一一对应的映射，
hash有了用武之地。也不难想到把字符串按26进制
映射成一个十进制数字，然后数组再映射成对应的下标，
但是映射成的十进制数字可能越界，
所以用前式链向星，把每个字符串先搞到hash桶中，
当然会有多个字符串在一个hash桶中，这就对应了图的概念
可以用链向星把桶作为节点，字符串作为边，把下标也存储到结构体中，
这样每次搜索按链向星搜索便可以找到对应的下标。

#include<bits/stdc++.h>
using namespace std;

#define debug puts("YES");
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define ll long long

#define lrt int l,int r,int rt
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define root l,r,rt
#define mst(a,b) memset((a),(b),sizeof(a))
#define pii pair<int,int>
#define fi first
#define se second
#define mk(x,y) make_pair(x,y)
const int maxn=6e4+4;
const int ub=1e6;
///ll powmod(ll x,ll y){ll t; for(t=1;y;y>>=1,x=x*x%mod) if(y&1) t=t*x%mod; return t;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
/*
题目大意：给定若干个长度一样的字符串，
从第一个字符串出发，每次操作可以改变一个字符，
问要变成最后一个字符串最少需要几次变换，
并且打印路径。

常规的搜索题，一开始很容易想到用MAP结构，
但会被超时，如何从若干个字符串中找到一一对应的映射，
hash有了用武之地。也不难想到把字符串按26进制
映射成一个十进制数字，然后数组再映射成对应的下标，
但是映射成的十进制数字可能越界，
所以用前式链向星，把每个字符串先搞到hash桶中，
当然会有多个字符串在一个hash桶中，这就对应了图的概念
可以用链向星把桶作为节点，字符串作为边，把下标也存储到结构体中，
这样每次搜索按链向星搜索便可以找到对应的下标。
*/

string s[maxn];
map<string,int> mp;///容器超时
///搞个前世链向星来玩hash。
struct edge{
    ll v;
    int id,nxt;
}e[maxn];
const int mod=1e7+9;
int tot,head[mod];
int H[11][33];
ll p[11],a[maxn];///
void init(){
    mst(head,-1),tot=0;
    p[0]=1;rep(i,1,10) p[i]=p[i-1]*26LL;
    rep(i,0,10) rep(j,0,26) H[i][j]=rand();
}
ll deal(string s){
    ll ans=0;rep(i,0,s.size()) ans=ans+p[i]*(s[i]-'a');
    return ans;
}///把字符串映射成唯一的数值
int Hash(string s){
    int ans=0;
    rep(i,0,s.size()) ans=(ans+H[i][s[i]-'a'])%mod;
    return ans;///
}
void add(int x){
    int tmp=Hash(s[x]);
    e[tot].v=a[x];
    e[tot].id=x;
    e[tot].nxt=head[tmp];
    head[tmp]=tot++;
}
int query(int h,ll v){
    for(int i=head[h];~i;i=e[i].nxt)
        if(e[i].v==v) return e[i].id;
    return -1;
}
int n,vis[maxn],pre[maxn];///bfs所需要的数据
void output(int x){
    if(x<=0) return ;
    output(pre[x]);
    cout<<s[x]<<endl;
}
void bfs(){
    queue<int> q;q.push(1);
    mst(vis,-1),vis[1]=0;
    int len=s[1].size();
    string ts;
    while(!q.empty()){
        int tp=q.front();q.pop();
        ///cout<<s[tp]<<endl;
        if(tp==n) return;
        ts=s[tp];
        int h=Hash(ts);
        ll v=a[tp];///取值
        rep(i,0,len) rep(j,0,26) if(ts[i]!='a'+j){
            h-=H[i][ts[i]-'a'],h+=H[i][j];
            v-=p[i]*(ts[i]-'a'),v+=p[i]*j;
            int ret=query(h,v);
            h+=H[i][ts[i]-'a'],h-=H[i][j];
            v+=p[i]*(ts[i]-'a'),v-=p[i]*j;
            if(ret<0 || vis[ret]!=-1 ){continue;}
            pre[ret]=tp,vis[ret]=vis[tp]+1;
            q.push( ret);
        }
    }
}

int main(){

    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);

    init();///
    scanf("%d",&n);
    rep(i,1,n+1){
        cin>>s[i];
        a[i]=deal(s[i]);
        add(i);///
    }
    bfs();
    if(vis[n]==-1) puts("FAIL");
    else {printf("%d\n",vis[n]+1);output(n);}
    return 0;
}