(bfs)leetcode困难127. 单词接龙

题目

字典 wordList 中从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列 beginWord -> s1 -> s2 -> … -> sk：

每一对相邻的单词只差一个字母。
对于 1 <= i <= k 时，每个 si 都在 wordList 中。注意， beginWord 不需要在 wordList 中。
sk == endWord
给你两个单词 beginWord 和 endWord 和一个字典 wordList ，返回 从 beginWord 到 endWord 的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列，返回 0 。

示例 1：

输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]
输出：5
解释：一个最短转换序列是 “hit” -> “hot” -> “dot” -> “dog” -> “cog”, 返回它的长度 5。
示例 2：

输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”]
输出：0
解释：endWord “cog” 不在字典中，所以无法进行转换。

提示：

1 <= beginWord.length <= 10
endWord.length == beginWord.length
1 <= wordList.length <= 5000
wordList[i].length == beginWord.length
beginWord、endWord 和 wordList[i] 由小写英文字母组成
beginWord != endWord
wordList 中的所有字符串 互不相同

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/word-ladder
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析

题目中限定，进行单词转换需要这两个单词相差一个字母，如果有多个单词的时候我们应该转换成哪个单词，从而到达目标的次数最小呢，这时我们就可以遍历可以转换的单词，然后再遍历转换后的单词是否存在目标单词，如果不存在，就继续遍历当前单词能转换的单词，直到找到目标或者遍历结束，到这里就可以确定这是一道bfs的题
首先应该确定单词之间的关系，每个单词可以直接转换成哪些单词，这些单词都应该跟这个单词绑定存储起来（邻接表）
然后在邻接表中bfs，找到目标时既是答案次数

代码部分

1.构建和初始化邻接表

我们要将一个字符串和它能直接转换的字符串绑定，所以这里就用到了map和pair，pair用来绑定当前字符串和字符串数组

		map<string,vector<string> > graph;	//邻接表 
		wordList.push_back(beginWord);
		
		for(int i=0;i<wordList.size();i++)	//初始化 
		{
			graph[wordList[i]]=vector<string>();
		}
		
		for(int i=0;i<wordList.size();i++)		//构建邻接表 
		{
			for(int j=i+1;j<wordList.size();j++)
			{
				if(check(wordList[i],wordList[j]))
				{
					graph[wordList[i]].push_back(wordList[j]);
					graph[wordList[j]].push_back(wordList[i]);
				}
			}
		}

2.bfs部分

我们要做的事情就是遍历每一层直到找到答案或者全部遍历完，bfs要用到队列，队列中的每个元素的组成应该是什么呢，首先是当前的字符串，然后是当前的的步数我们要记下来（答案需要），所以这里我们的队列的每个元素是pair<string,int>
然后需要一个数组来储存我们走过的字符串，避免死循环，这里我们用set来存储走过的字符串
每次都pop掉队首的元素，赋值给当前要处理的字符串，然后再将跟它相连的所有字符串push进来，并且标记为已经走过，每次pop时判断当前的字符串是否为目标字符串，如果是就直接返回，然后再循环结束的地方返回0，这里说明没有找到目标字符串，说明目标字符串不在字符串数组中，或者没有字符串可以直接转换成目标字符串

	int bfs(string beginWord, string endWord,
	vector<string>& wordList,map<string,vector<string> > &graph)
	{
		//出口
		
		//现在能做的事情
		queue<pair<string,int> > Q;		//搜索队列 顶点,步数
		Q.push(make_pair(beginWord,1));
		set<string> vis;		//记录走过单词
		vis.insert(beginWord);
		
		while(!Q.empty())
		{
			string node=Q.front().first;	//顶点 
			int step=Q.front().second;		//步数
			Q.pop();
			if(node==endWord)
				return step;
			const vector<string> neighbors=graph[node]; 
			for(int i=0;i<graph[node].size();i++)
			{
				if(vis.find(neighbors[i])==vis.end())
				{
					vis.insert(neighbors[i]);
					Q.push(make_pair(neighbors[i],step+1));
				}
			} 
		} 
		
		return 0;
	}

完整代码

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

class Solution {
public:
	bool check(string s1,string s2)
	{
		int cnt=0;
		for(int i=0;i<s1.size();i++)
			if(s1[i]!=s2[i])
				cnt++;
				
		return cnt==1;
	}
	
	
	int bfs(string beginWord, string endWord,
	vector<string>& wordList,map<string,vector<string> > &graph)
	{
		//出口
		
		//现在能做的事情
		queue<pair<string,int> > Q;		//搜索队列 顶点,步数
		Q.push(make_pair(beginWord,1));
		set<string> vis;		//记录走过单词
		vis.insert(beginWord);
		
		while(!Q.empty())
		{
			string node=Q.front().first;	//顶点 
			int step=Q.front().second;		//步数
			Q.pop();
			if(node==endWord)
				return step;
			const vector<string> neighbors=graph[node]; 
			for(int i=0;i<graph[node].size();i++)
			{
				if(vis.find(neighbors[i])==vis.end())
				{
					vis.insert(neighbors[i]);
					Q.push(make_pair(neighbors[i],step+1));
				}
			} 
		} 
		
		return 0;
	}
	
	
    int ladderLength(string beginWord, string endWord,
	 vector<string>& wordList) {
		map<string,vector<string> > graph;	//邻接表 
		wordList.push_back(beginWord);
		
		for(int i=0;i<wordList.size();i++)	//初始化 
		{
			graph[wordList[i]]=vector<string>();
		}
		
		for(int i=0;i<wordList.size();i++)		//构建邻接表 
		{
			for(int j=i+1;j<wordList.size();j++)
			{
				if(check(wordList[i],wordList[j]))
				{
					graph[wordList[i]].push_back(wordList[j]);
					graph[wordList[j]].push_back(wordList[i]);
				}
			}
		} 

/*		
		//输出构造好的邻接表 
		for(int i=0;i<wordList.size();i++)
		{
			cout<<wordList[i]<<": ";
			const vector<string> neighbors=graph[wordList[i]];
			for(int j=0;j<neighbors.size();j++)
			{
				cout<<neighbors[j]<<" ";
			}
			cout<<endl;
		}
*/		
		
		int ans=bfs(beginWord,endWord,wordList,graph);
		
		return ans;
    }
};

int main (void)
{
	string beginWord = "hit", endWord = "cog";
	vector<string> wordList={"hot","dot","dog","lot","log","cog"};
	Solution s;
	cout<<s.ladderLength(beginWord,endWord,wordList);
	
	return 0;
}

总结

遇到搜索的题，一定要先判断用哪种方式更合适，bfs或dfs或者加记忆化的dfs，这道题用bfs就显然更合适，按层遍历返回先找到的哪个目标字符串一定是步数最少的，刚开始我用了记忆化的bfs也只过了一半的用例