算法：127. Word Ladder用一圈一圈的波浪法解决 词梯子

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.

广度优先拆解解法

根据波浪扩散，由内而外地扩散，广度优先算法找出最短路径

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        HashSet<String> wordSet = new HashSet<>(wordList);
        if (!wordSet.contains(endWord)) return 0;
        
        wordSet.remove(beginWord);
        
        HashSet<String> reachSet = new HashSet<>();
        reachSet.add(beginWord);
        
        int count = 0;
        // expand cicirl wave
        while (!reachSet.isEmpty()) {
            HashSet<String> newReachSet = new HashSet<>();
            count++;
            
            for (String currentWord: reachSet) {
                for (String nextWord: getNextWords(currentWord, wordSet)) {
                    if (wordSet.remove(nextWord)) {
                        if (nextWord.equals(endWord)) {
                            return count + 1;
                        }
                        newReachSet.add(nextWord);
                    }
                }
            }
            
            reachSet = newReachSet;
        }
        
        return 0;
    }
    
    private List<String> getNextWords(String currentWord, HashSet<String> wordSet) {
        List<String> list = new ArrayList<>();
        for (String word: wordSet) {
            if (isOneLetterAway(currentWord, word)) {
                list.add(word);
            }
        }
        
        return list;
    }
    
    private boolean isOneLetterAway(String currentWord, String word) {
        boolean oneWay = true;
        char[] currentChars = currentWord.toCharArray();
        char[] wordChars = word.toCharArray();
        for (int i = 0; i < currentChars.length; i++) {
            if (currentChars[i] == wordChars[i]) continue;
            
            if (oneWay) {
                oneWay = false;
            } else {
                return false;
            }
        }
        
        return true;
    }
}

效率比较高的解法

这种方法不是遍历所有单词，而是遍历字母a~z, 可能是如果单词列表较大的时候有优势

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;
    }
}