单词接龙
来源：力扣（LeetCode） 链接：leetcode.cn/problems/wo…
字典 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 中的所有字符串 互不相同
代码
import java.util.*;
class Solution {
public int ladderLength(String beginWord, String endWord, List<String> wordList) {
Set<String> wordSet = new HashSet<>(wordList);
if (!wordSet.contains(endWord)) {
return 0;
}
Queue<String> queue = new LinkedList<>();
queue.offer(beginWord);
int level = 1;
while (!queue.isEmpty()) {
int size = queue.size();
for (int i = 0; i < size; i++) {
String currentWord = queue.poll();
char[] wordArray = currentWord.toCharArray();
for (int j = 0; j < wordArray.length; j++) {
char originalChar = wordArray[j];
for (char c = 'a'; c <= 'z'; c++) {
wordArray[j] = c;
String transformedWord = new String(wordArray);
if (transformedWord.equals(endWord)) {
return level + 1;
}
if (wordSet.contains(transformedWord)) {
queue.offer(transformedWord);
wordSet.remove(transformedWord);
}
}
wordArray[j] = originalChar;
}
}
level++;
}
return 0;
}
}
思路分析
-
首先将单词列表转换为一个哈希集合，以便于快速判断某个单词是否在列表中。
-
如果目标单词不在列表中，直接返回0，表示无法进行转换。
-
创建一个队列用于存储待处理的单词，并将起始单词加入队列中。
-
初始化一个level变量为1，表示起始单词所在的层级。
-
进行循环，直到队列为空：
- 在每一层中，首先获取当前层级的单词数量。
- 依次取出队列中的单词，将其每个字符逐个替换为字母'a'到'z'，生成新的单词。
- 如果新的单词等于目标单词，表示已经找到了最短转换序列，返回当前层级+1。
- 如果新的单词在单词列表中，并且没有被访问过，将其加入队列，并将其从单词列表中移除，表示已访问过。
-
如果最终没有找到目标单词，返回0，表示无法进行转换。
单词接龙||
来源：力扣（LeetCode） 链接：leetcode.cn/problems/wo…
按字典 wordList 完成从单词 beginWord 到单词 endWord 转化，一个表示此过程的 转换序列 是形式上像 beginWord -> s1 -> s2 -> ... -> sk 这样的单词序列，并满足：
- 每对相邻的单词之间仅有单个字母不同。
- 转换过程中的每个单词 si（1 <= i <= k）必须是字典 wordList 中的单词。注意，beginWord 不必是字典 wordList 中的单词。
- sk == endWord
给你两个单词 beginWord 和 endWord ，以及一个字典 wordList 。请你找出并返回所有从 beginWord 到 endWord 的 最短转换序列 ，如果不存在这样的转换序列，返回一个空列表。每个序列都应该以单词列表 [beginWord, s1, s2, ..., sk] 的形式返回。
示例 1：
输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
输出：[["hit","hot","dot","dog","cog"],["hit","hot","lot","log","cog"]]
解释：存在 2 种最短的转换序列：
"hit" -> "hot" -> "dot" -> "dog" -> "cog"
"hit" -> "hot" -> "lot" -> "log" -> "cog"
示例 2：
输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
输出：[]
解释：endWord "cog" 不在字典 wordList 中，所以不存在符合要求的转换序列。
提示：
- 1 <= beginWord.length <= 5
- endWord.length == beginWord.length
- 1 <= wordList.length <= 500
- wordList[i].length == beginWord.length
- beginWord、endWord 和 wordList[i] 由小写英文字母组成
- beginWord != endWord
- wordList 中的所有单词 互不相同
代码
import java.util.*;
public class Solution {
public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
List<List<String>> results = new ArrayList<>();
Set<String> wordSet = new HashSet<>(wordList);
if (!wordSet.contains(endWord)) {
return results;
}
// 使用BFS找到最短路径
Queue<List<String>> queue = new LinkedList<>();
List<String> initialPath = new ArrayList<>();
initialPath.add(beginWord);
queue.offer(initialPath);
// 使用Set记录已访问过的单词
Set<String> visited = new HashSet<>();
visited.add(beginWord);
boolean found = false;
while (!queue.isEmpty() && !found) {
int size = queue.size();
Set<String> levelVisited = new HashSet<>();
for (int i = 0; i < size; i++) {
List<String> path = queue.poll();
String currentWord = path.get(path.size() - 1);
char[] chars = currentWord.toCharArray();
for (int j = 0; j < chars.length; j++) {
char originalChar = chars[j];
for (char c = 'a'; c <= 'z'; c++) {
if (c == originalChar) {
continue;
}
chars[j] = c;
String nextWord = String.valueOf(chars);
if (wordSet.contains(nextWord)) {
List<String> newPath = new ArrayList<>(path);
newPath.add(nextWord);
if (nextWord.equals(endWord)) {
results.add(newPath);
found = true;
} else {
queue.offer(newPath);
levelVisited.add(nextWord);
}
}
}
chars[j] = originalChar;
}
}
visited.addAll(levelVisited);
}
return results;
}
}
思路分析
该题目可以使用广度优先搜索（BFS）的方法来求解。首先将起始单词加入队列，然后通过不断替换单词中的字符，并判断替换后的单词是否在字典中存在，如果存在则将替换后的单词加入队列，并将路径也进行更新。在搜索过程中，需要使用一个Set集合来记录已经访问过的单词，避免重复访问。当找到目标单词时，将路径添加到结果集中。
代码中使用了两个Set集合，visited用于记录已访问过的单词，levelVisited用于记录当前层次中已访问过的单词。这样可以避免同一层次中的重复访问。最后返回结果集即可。
