leetcode笔记——127单词接龙

题目：

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

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

说明:

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

示例 1:

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

输出: 5

解释: 一个最短转换序列是 "hit" -> "hot" -> "dot" -> "dog" -> "cog",
     返回它的长度 5。

示例 2:

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

输出: 0

解释: endWord "cog" 不在字典中，所以无法进行转换。

思路：在网上百度的代码。原文链接：https://www.cnblogs.com/tengdai/p/9249543.html

思路是使用广度优先搜索。是单源头广度优先搜索最短路径。以开始单词为图的源点，当字典中的单词和源头相差一个字母时，将两个节点链接起来，这样就组成了一幅图。那么根据广度优先搜索的步骤，构建一个队列，之后先把源顶点加入队列，以队列是否为空作为条件开始循环：如果队列不为空，逐个取出队列中的顶点，并把它们标记为“已访问”。对于每个取出的顶点，依次把它未访问的顶点加入队列，直到找到目标顶点或者所有顶点都访问完毕。因为此题只是求最短路径的长度，而不是路径上都有哪些顶点，所以只需要存储每访问一个顶点时该顶点处在路径的位置即可。这里我用了HashMap<String, Integer>。如果是需要存储最短路径本身，那么需要建立数据结构依次存储每个顶点的前驱，并在最后追溯前驱获得路径上的所有顶点。

代码：

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        HashSet<String> wordSet = new HashSet<>(wordList); //替换掉题目中List结构，加速查找
        if (!wordSet.contains(endWord)) return 0; //如果目标顶点不在图中，直接返回0
        HashMap<String, Integer> map = new HashMap<>(); //用来存储已访问的节点，并存储其在路径上的位置，相当于BFS算法中的isVisted功能
        Queue<String> q = new LinkedList<>(); //构建队列，实现广度优先遍历
        q.add(beginWord); //加入源顶点
        map.put(beginWord, 1); //添加源顶点为“已访问”，并记录它在路径的位置
        while (!q.isEmpty()) { //开始遍历队列中的顶点
            String word = q.poll(); //记录现在正在处理的顶点
            int level = map.get(word); //记录现在路径的长度
            for (int i = 0; i < word.length(); i++) {
                char[] wordLetter = word.toCharArray();
                for (char j = 'a'; j <= 'z'; j++) {
                    if (wordLetter[i] == j) continue; 
                    wordLetter[i] = j; //对于每一位字母，分别替换成另外25个字母
                    String check = new String(wordLetter);
                    if (check.equals(endWord)) return map.get(word) + 1; //如果已经抵达目标节点，返回当前路径长度+1
                    if (wordSet.contains(check) && !map.containsKey(check)) { //如果字典中存在邻接节点，且这个邻接节点还未被访问
                        map.put(check, level + 1); //标记这个邻接节点为已访问，记录其在路径上的位置
                        q.add(check); //加入队列，以供广度搜索
                    }
                }
            }
        }
        return 0;
    }
}

 

执行最快的代码：

执行最快的代码好像也是广度优先搜索，但是和上面的实现方法不一样。有点看不懂。。。。。

class Solution {
  public int ladderLength(String beginWord, 
			String endWord, List<String> wordList) {
        //首先建立一个字典，将每个单词放入其中
        Set<String> dict=new HashSet<String>();
        for (String word : wordList) {
            dict.add(word);
        }
        if (!dict.contains(endWord)){
            return 0;
        }
        //建立头尾队列
        Set<String> beginSet=new HashSet<>();
        Set<String> endSet=new HashSet<>();
        beginSet.add(beginWord);
        endSet.add(endWord);

        int level=0;
        //遍历队列
        while (!beginSet.isEmpty()&&!endSet.isEmpty()){
            level++;
            //确保头集合较小，保持平衡
            if (beginSet.size()>endSet.size()){
                Set<String> t=endSet;
                endSet=beginSet;
                beginSet=t;
            }

            //建立一个临时集合
            Set<String> temp=new HashSet<>();

            for (String word : beginSet) {
                char[] chars = word.toCharArray();
                for (int i = 0; i < chars.length; i++) {
                    char ch=chars[i];
                    for (char j = 'a'; j <='z' ; j++) {
                        chars[i]=j;
                        String s = new String(chars);
                        if (endSet.contains(s)){
                            return level+1;
                        }
                        if (dict.contains(s)){
                            dict.remove(s);
                            temp.add(s);
                        }
                    }
                    chars[i]=ch;  
                }
            }
            beginSet=temp;

        }
        return 0;
  }
}