[LeetCode] 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.

单词接龙。

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

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

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

这道题的思路是BFS，不难想到。通过这道题，我们需要学会一个BFS加速的办法，双向BFS。

首先是普通的BFS。我们将 beginWord 放入队列，然后修改 beginWord 里的每一个字母，看看下一个单词是否存在于 wordList，如果存在的话，这条路就能继续走下去。我们需要返回的是一条最短路径。

时间O(n)

空间O(n)

Java实现

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        HashSet<String> set = new HashSet<>(wordList);
        // corner case
        if (set.size() == 0 || !set.contains(endWord)) {
            return 0;
        }

        // normal case
        set.remove(beginWord);
        Queue<String> queue = new LinkedList<>();
        queue.offer(beginWord);
        HashSet<String> visited = new HashSet<>();
        int step = 1;
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                String curWord = queue.poll();
                if (helper(curWord, endWord, queue, visited, set)) {
                    return step + 1;
                }
            }
            step++;
        }
        return 0;
    }

    private boolean helper(String curWord, String endWord, Queue<String> queue, HashSet<String> visited, HashSet<String> set) {
        char[] letter = curWord.toCharArray();
        for (int i = 0; i < endWord.length(); i++) {
            char origin = letter[i];
            for (char j = 'a'; j <= 'z'; j++) {
                if (j == origin) {
                    continue;
                }
                letter[i] = j;
                String nextWord = String.valueOf(letter);
                if (set.contains(nextWord)) {
                    if (nextWord.equals(endWord)) {
                        return true;
                    }
                    if (!visited.contains(nextWord)) {
                        queue.offer(nextWord);
                        visited.add(nextWord);
                    }
                }
            }
            letter[i] = origin;
        }
        return false;
    }
}

 

双向 BFS 的思路是我们需要对 beginWord 和 endWord 分别使用一个 hashset，并且对 beginWord 和 endWord 同时修改一个字母，看看下一个单词是否存在于 wordList。这里面还有一个技巧，假设 beginWord 和 endWord 各自衍生出了一个 nextList，我们只需要再次遍历那个更短的 nextList 以节省时间。双向 BFS 会比第一种 BFS 节省一半的时间。

时间O(n)

空间O(n)

Java实现

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        HashSet<String> set = new HashSet<>(wordList);
        // corner case
        if (set.size() == 0 || !set.contains(endWord)) {
            return 0;
        }

        // normal case
        HashSet<String> visited = new HashSet<>();
        HashSet<String> beginVisited = new HashSet<>();
        beginVisited.add(beginWord);
        HashSet<String> endVisited = new HashSet<>();
        endVisited.add(endWord);

        int step = 1;
        while (!beginVisited.isEmpty() && !endVisited.isEmpty()) {
            // 优先选择小的哈希表进行扩散，考虑到的情况更少
            if (beginVisited.size() > endVisited.size()) {
                HashSet<String> temp = beginVisited;
                beginVisited = endVisited;
                endVisited = temp;
            }

            HashSet<String> nextLevelVisited = new HashSet<>();
            for (String word : beginVisited) {
                if (helper(word, endVisited, visited, set, nextLevelVisited)) {
                    return step + 1;
                }
            }
            beginVisited = nextLevelVisited;
            step++;
        }
        return 0;
    }

    private boolean helper(String word, HashSet<String> endVisited,
            HashSet<String> visited,
            HashSet<String> wordSet,
            HashSet<String> nextLevelVisited) {
        char[] letter = word.toCharArray();
        for (int i = 0; i < word.length(); i++) {
            char origin = letter[i];
            for (char c = 'a'; c <= 'z'; c++) {
                if (origin == c) {
                    continue;
                }
                letter[i] = c;
                String nextWord = String.valueOf(letter);
                if (wordSet.contains(nextWord)) {
                    if (endVisited.contains(nextWord)) {
                        return true;
                    }
                    if (!visited.contains(nextWord)) {
                        nextLevelVisited.add(nextWord);
                        visited.add(nextWord);
                    }
                }
            }
            // 恢复，下次再用
            letter[i] = origin;
        }
        return false;
    }
}

 

LeetCode 题目总结