LeetCode 127 单词接龙

题目

给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则：

每次转换只能改变一个字母。
转换过程中的中间单词必须是字典中的单词。
说明:

如果不存在这样的转换序列，返回 0。
所有单词具有相同的长度。
所有单词只由小写字母组成。
字典中不存在重复的单词。
你可以假设 beginWord 和 endWord 是非空的，且二者不相同。

解法一

这个采用BFS来进行转换查询，一层一层的往外扩散，直到查询到最短的转换序列

• 首先，将beginWord 放入队列中，作为第0层。
• 然后将队列的元素拿出来，查询字典中的单词 能一次转换成功，就将这些单词放入队列中。同时还需要visited的Set 用来记录字典的单词是否已经访问过
• 队列中一层的元素结束后，转换的长度+1，然后再继续进行下一层元素的转换。直到转换成功

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        if (!wordList.contains(endWord)) 
            return 0;
        Set<String> visited = new HashSet<>(); //用来记录已经访问过的元素
        Queue<String> queue = new LinkedList<>();
        queue.offer(beginWord); //放入第一个元素，第一层 就只有beginWord
        visited.add(beginWord);
        int count = 0; //长度一开始0
        while (queue.size() > 0) { //队列不为空就一直循环
            int size = queue.size(); //记录当前层的元素数量，区分层数
            count++;
            for (int i = 0; i < size; i++) { //循环同一层的元素
                String start = queue.poll();
                for (String s : wordList) {
                    if (visited.contains(s)) continue; //单词已经访问过，就直接跳过
                    if (!canConvert(start, s)) continue;//单词不能进行一次转换，跳过
                    if (s.equals(endWord)) return ++count;//直接返回count+1.
                    visited.add(s);
                    queue.offer(s);
                }
            }
        }
        return 0;
    }
    public boolean canConvert (String start, String s) { //判断start，和s 之间能否进行一次转换，就是只有一个字母的差异。
        if (start.length() != s.length()) return false;
        int count = 0;
        for (int i = 0; i < start.length(); i++) {
            if (start.charAt(i) != s.charAt(i)) count++;
            if (count > 1) return false;
        }
        return count == 1;
    }          
}

复杂度分析

时间复杂度：

解法二 双向BFS

使用俩个队列进行BFS

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        if (!wordList.contains(endWord)) 
            return 0;
        Queue<String> queue1 = new LinkedList<>();
        Queue<String> queue2 = new LinkedList<>();
        Set<String> visited1 = new HashSet<>();
        Set<String> visited2 = new HashSet<>();
        queue1.offer(beginWord);  //一个从头开始
        queue2.offer(endWord);    //一个从尾开始
        visited1.add(beginWord);
        visited2.add(endWord);
        int count = 0;
        while (!queue1.isEmpty() && !queue2.isEmpty()) {
            count++;
            if (queue1.size() > queue2.size()) {  //每一次进行遍历时，从结点少的那一层开始遍历
                Queue<String> tmp = queue1;
                queue1 = queue2;
                queue2 = tmp;
                Set<String> t = visited1;
                visited1 = visited2;
                visited2 = t;
            }
            int size = queue1.size();
            while (size-- > 0) {  //遍历同一层
                String start = queue1.poll();
                for (String s : wordList) {
                    if (visited1.contains(s)) continue;
                    if (!canConvert(start, s)) continue;
                    if (visited2.contains(s)) return ++count;  //这里当俩边的visited有重复，说明打通了，直接返回
                    visited1.add(s);
                    queue1.offer(s);
                }
            }
        }
        return 0;
    }
    public boolean canConvert (String start, String s) {
         if (start.length() != s.length()) return false;
         int count = 0;
         for (int i = 0; i < start.length(); i++) {
             if (start.charAt(i) != s.charAt(i)) count++;
             if (count > 1) return false;
         }
         return count == 1;
    }   
}