127. Word Ladder

原创于 2020-02-09 15:10:43 发布 · 114 阅读

0 ·

CC 4.0 BY-SA版权

LEETCODE 专栏收录该内容

144 篇文章

订阅专栏

本文介绍了一种使用BFS算法解决单词梯问题的方法，通过优化查找过程，避免了超时问题，实现从开始单词到结束单词的最短转换路径。

Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:

Only one letter can be changed at a time.
Each transformed word must exist in the word list. Note that beginWord is not a transformed word.
Note:

Return 0 if there is no such transformation sequence.
All words have the same length.
All words contain only lowercase alphabetic characters.
You may assume no duplicates in the word list.
You may assume beginWord and endWord are non-empty and are not the same.
Example 1:

Input:
beginWord = "hit",
endWord = "cog",
wordList = ["hot","dot","dog","lot","log","cog"]

Output: 5

Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.
Example 2:

Input:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

Output: 0

Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.

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

用BFS算法，相当于树的层次遍历，遍历到目标的word，就返回层次。

直接用BFS会超时，这里做两个优化：

1. 把wordList用HashMap储存。

2. 在找下一个可达的字符串时，遍历当前字符串的字母，每个字符都变成‘a’ - ‘z’，然后看wordList中是否存在，存在即可达，这样复杂度是当前字符串的长度*26，而不是wordList.size()。

3. 用一个HashMap储存遍历过的字符串。

class Solution {
    boolean canTrans(String s1, String s2) {
        int ans = 0;
        for (int i = 0; i < s1.length(); i++) {
            if (s1.charAt(i) != s2.charAt(i)) {
                ans++;
            }
        }
        return ans == 1;
    }

    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        Set<String> words = new HashSet<String>(wordList);
        Set<String> visit = new HashSet<>();
        Queue<String> queue = new ArrayDeque<>();
        for (int j = 0; j < beginWord.length(); j++) {
            char[] chars = beginWord.toCharArray();
            for (char k = 'a'; k <= 'z'; k++) {
                chars[j] = k;
                String tmp = new String(chars);
                if (words.contains(tmp) && !visit.contains(tmp)) {
                    queue.add(tmp);
                }
            }
        }

        int level = 1;
        int lastLevelSize = queue.size();
        while (!queue.isEmpty()) {
            for (int i = 0; i < lastLevelSize; i++) {
                String current = new String(queue.remove());
                visit.add(current);
                if (current.compareTo(endWord) == 0){
                    return level + 1;
                }

                for (int j = 0; j < current.length(); j++) {
                    char[] chars = current.toCharArray();
                    for (char k = 'a'; k <= 'z'; k++) {
                        chars[j] = k;
                        String tmp = new String(chars);
                        if (words.contains(tmp) && !visit.contains(tmp)) {
                            queue.add(tmp);
                        }
                    }
                }
            }
            lastLevelSize = queue.size();
            level++;
        }
        return 0;
    }
}