【6.12校内test】T1单词序列

【问题描述】

给出两个单词（开始单词和结束单词）以及一个词典。找出从开始单词转换到结束单词， 所需要的最短转换序列。转换的规则如下：

1、每次只能改变一个字母

2、转换过程中出现的单词(除开始单词和结束单词)必须存在于词典中

例如： 开始单词为：hit

结束单词为：cog

词典为：[hot,dot,dog,lot,log,mot]

那么一种可能的最短变换是： hit -> hot -> dot -> dog -> cog,

所以返回的结果是序列的长度 5；

注意： 1、如果不能找到这种变换，则输出 0；

2、词典中所有单词长度一样；

3、所有的单词都由小写字母构成；

4、开始单词和结束单词可以不在词典中。

【输入文件】

共两行，第一行为开始单词和结束单词（两个单词不同），以空格分开。第二行为若干 的单词（各不相同），以空格分隔开来，表示词典。单词长度不超过 5,单词个数不超过 30。

【输出文件】

输出转换序列的长度。

【输入样例】

hit cog

hot dot dog lot log

【输出样例】

5

【数据范围】

单词长度不超过5，单词个数不超过30；

---

这个题算法大概是搜索，这可真的是令人质壁分离。

还记得我烤鸡写了一个多小时呀qwq（果真还是我太菜了），感觉自己代码能力真心不好呀，我可能也就for写的足够优秀了emmm。

（滚去写这个题代码了）

MY SOLUYION：
first.这个题读入就很卡人，下面我们来总结一下输入若干个（题目未给出具体的数值）应该肿么写：

1. 输入一串长度不定的字符串

   string a;
   cin>>a;//直接用string然后cin或scanf输入就好；

2. 今天用到的（我的写法）(自我感觉良好）

   while(ch!='\n'){
           n++;
           scanf("%s",dic[n].g);
           ch=getchar();
       }//因为输入时两个字符串之间会间隔一个空格，因此我们getchar（）掉这个空格，getchar的这个空格记为ch，当ch='\n'（即说明读到了回车），那么很显然的，就不应该读下去了

3. 之前sy讲得：（感觉我们的是差不多的嘞qwq）

   char bj=' ',i=;//bj即为标记，i为数组下标（多个数用数组比较方便）
     while(bj==' ')//因为输完数要按空格
     {cin>>a[++i];
     bj=getchar();
   
   一行内输入n个整数

4. 神仙们的写法：

   //楼下捕捉一只yjk神仙
   while(cin>>s[++n]);
   //好像神仙们都是这么写的，就我这种蒟蒻写的这么复杂emm

然后因为方便计算，我把str和end加入了这n个单词之后，在字典有的单词的基础上+2

//输入部分
scanf("%s",str);
    scanf("%s",end);
    len=strlen(str);
    while(ch!='\n'){
        n++;
        scanf("%s",dic[n].g);
        ch=getchar();
    }
    for(int i=;i<len;i++) dic[n+].g[i]=str[i],dic[n+].g[i]=end[i];
    n+=;ss=n-;ee=n;

next.因为数据比较小嘛，所以我的想法是开一个二维数组cy（chayi）[i][j]，表示第i个单词与第j个单词的差异，然后大概应该可能是用dfs计算，然后出结果；对于预处理：

• 因为每个单词长度都不超过5，所以直接爆扫就可以了；为了看着比较简洁好看，我们写一个bj（比较）函数；二重循环（为了减少时间，我们可以把j从i+1开始循环，然后双向存储） 注意：cy[i][i]=0；（其实这个倒是也不重要因为dfs时会忽略i==j的情况）
• 对于bj函数，返回的是第i个单词与第j个单词相差的字母数量；

  //比较函数与预处理
  int bj(char a[],char b[]){
      int c=;
      for(int i=;i<len;i++)
        if(a[i]!=b[i]) c++;
      return c;
  }
  ……
  
  for(int i=;i<=n;i++)
        for(int j=i+;j<=n;j++)
           cy[j][i]=cy[i][j]=bj(dic[i].g,dic[j].g),cy[i][i]=;

end.代码的核心dfs部分：

1. 定义两个变量进行dfs：begin/*表示从哪个单词开始搜索下一个单词*/，ans/*记录进行了几次变换*/
2. 在主程序中dfs（ss/*表示起点的编号*/，1/*由样例可知，str与end也要算在内，因此从1开始*/
3. 先是临界条件：当当前dfs到的编号刚好是end的标号ee时，用f数组记录下这个解（显然dfs会搜索出所有转化情况，而我们只取最小的一种，因此要把每一种记录下来，最后sort求解）return 1（对于这个return 1是用来判断是否有解的）
4. vis数组，用来判断某一个点是否已经搜索过
5. 定义一个next，利用for循环找到一个与begin的差异只有1的点[如果没有显然这种情况不成立，也就是无解，因此定义一个bj=0，如果找到了差异是1的点，bj=1，在dfs的最后，如果bj=0，就说明无解，返回0]，令next=i；标记vis[next]为已经搜索（1）；bj=1；然后搜索（next，ans+1）；记得回溯使vis[next]=0；

以上就是大致算法流程。

CODE：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>

using namespace std;

char str[],end[],ch;
struct node1{
    char g[];
}dic[];
int n,cy[][],len,ss,ee,ans,f[],cnt;

int bj(char a[],char b[]){
    int c=;
    for(int i=;i<len;i++)
      if(a[i]!=b[i]) c++;
    return c;
}
bool vis[];

int solve(int begin,int ans){
    if(begin==ee) {
        f[++cnt]=ans;
        return ;
    }
    int next;
    int bj=;
    for(int i=;i<=n;i++){
        if(vis[i]) continue;
        if(i==begin) continue;
        if(cy[begin][i]!=) continue;

           next=i;vis[next]=;
           bj=;
           solve(next,ans+);
           vis[next]=;
    }
    if(!bj) return ;
}

int main(){
//    freopen("word2.in","r",stdin);
//    freopen("word.out","w",stdout);
    scanf("%s",str);
    scanf("%s",end);
    len=strlen(str);
    while(ch!='\n'){
        n++;
        scanf("%s",dic[n].g);
        ch=getchar();
    }
    for(int i=;i<len;i++) dic[n+].g[i]=str[i],dic[n+].g[i]=end[i];
    n+=;ss=n-;ee=n;
    for(int i=;i<=n;i++)
      for(int j=i+;j<=n;j++)
         cy[j][i]=cy[i][j]=bj(dic[i].g,dic[j].g),cy[i][i]=;
    vis[ss]=;
    if(solve(ss,)==)cout<<""<<endl;
    else{
        sort(f+,f+cnt+);
        cout<<f[]<<endl;
    }
    return ;
}

然后我们看一下标程：

CODE：

//加一句注释提醒自己并不想看标程，改天再看吧qwq
#include<cstdio>
#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
struct node{
    string s;
    int dep;
};
queue<node>q;
string ss,st,s[];
int vis[];
int n=;
int can(string s,string t){
    if(s.size()!=t.size()) return ;
    int c=;
    for(int i=;i<s.size();i++)
        if(s[i]!=t[i]) c++;
    return c==;
}
int bfs(){
    memset(vis,,sizeof(vis));
    q.push((node){ss,});
    while(!q.empty()){
        node cur=q.front();q.pop();
        if(cur.s==st) return cur.dep;//是目标
        if(can(cur.s,st)) return cur.dep+;//再一步就是目标
        for(int i=;i<n;i++)
            if(!vis[i]&&can(cur.s,s[i])){
                q.push((node){s[i],cur.dep+});
                vis[i]=;
            }
    }
    return ;
}
int main(){
    freopen("word.in","r",stdin);
    freopen("word.out","w",stdout);
    cin>>ss>>st;
    while(cin>>s[n++]);
    cout<<bfs()<<endl;
    return ;
}

end-