算法：127. Word Ladder单词阶梯查找

Posted 2021-06-12 架构师易筋

127. Word Ladder

A transformation sequence from word beginWord to word endWord using a dictionary wordList is a sequence of words beginWord -> s1 -> s2 -> ... -> sk such that:

Every adjacent pair of words differs by a single letter.
Every si for 1 <= i <= k is in wordList. Note that beginWord does not need to be in wordList.
sk == endWord
Given two words, beginWord and endWord, and a dictionary wordList, return the number of words in the shortest transformation sequence from beginWord to endWord, or 0 if no such sequence exists.

Example 1:

Input: beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
Output: 5
Explanation: One shortest transformation sequence is "hit" -> "hot" -> "dot" -> "dog" -> cog", which is 5 words long.

Example 2:

Input: beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
Output: 0
Explanation: The endWord "cog" is not in wordList, therefore there is no valid transformation sequence.

Constraints:

1 <= beginWord.length <= 10
endWord.length == beginWord.length
1 <= wordList.length <= 5000
wordList[i].length == beginWord.length
beginWord, endWord, and wordList[i] consist of lowercase English letters.
beginWord != endWord
All the words in wordList are unique.

思路解析

可以想象成水波纹一圈一圈往外扩散，也就是用广度优先算法BFS，每次转换一个字母。

1. 组建一个wordSet， 使得读取速度为O(1);
2. 创建一个level = 1， 表示遍历的层级；
3. 创建一个reachSet，表示当前可以达到的word；
4. 遍历reachSet，BFS广度优先就是遍历reachSet；
5. 如果找到多个下个目标，则填充到nextSet中，最终会替换到reachSet；
6. 每个遍历reachSet， level++；
7. 如此循环，如果找到endWord，则返回 level + 1;
8. 最终没有找到，则返回0.
   

代码实现

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        // Set
        Set<String> wordSet = new HashSet<>(wordList);
        Set<String> reachSet = new HashSet<>();
        
        // level 
        int level = 1;
        reachSet.add(beginWord);
        wordSet.remove(beginWord);
        
        // change one char
        while (!reachSet.isEmpty()) {
            Set<String> nextSet = new HashSet<>();
            for (String word: reachSet) {
                char[] chars = word.toCharArray();
                for (int i = 0; i < word.length(); i++) {
                    char oldChar = chars[i];
                    for (char c = 'a'; c <= 'z'; c++) {
                        chars[i] = c;
                        String newWord = new String(chars);
                        if (wordSet.remove(newWord)) {
                            if (newWord.equals(endWord)) return level + 1;
                            nextSet.add(newWord);
                        }
                    }
                    
                    chars[i] = oldChar;
                }
                
            }
            
            reachSet = nextSet;
            level++;
        }
        
        // return 0
        return 0;
    }
}

参考

https://leetcode.com/problems/word-ladder/discuss/40704/Java-Solution-using-BFS-with-explanation