☆打卡算法☆LeetCode 127. 单词接龙 算法解析

推荐阅读

• CSDN主页
• GitHub开源地址
• Unity3D插件分享
• 简书地址
• 我的个人博客
• QQ群：1040082875

大家好，我是小魔龙，Unity3D软件工程师，VR、AR，虚拟仿真方向，不定时更新软件开发技巧，生活感悟，觉得有用记得一键三连哦。

一、题目

1、算法题目

“给定两个单词beginWord和endWord，以及一个字典wordList，找出并返回所有从beginWord到endWrod之间的最短转换序列中的单词数目。”

题目链接：

来源：力扣（LeetCode）

链接： 127. 单词接龙 - 力扣（LeetCode） (leetcode-cn.com)

2、题目描述

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

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

示例 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" 不在字典中，所以无法进行转换。

二、解题

1、思路分析

这题是求两个单词的最短转换序列的长度，首先可以想到的就是使用广度优先搜索算法。

把每个单词抽象为一个顶点，两个单词只可以改变一个字母进行转换，将满足条件的条件的点相连。

寻找最短转换序列，需要输出所有的最短路径，因此需要记录遍历路径，然后通过回溯算法得到所有的最短路径。

因为需要对每一对的单词组合进行判断，所以可以建立一个哈希表，哈希表由单词word和单词的wordID映射，并将beginWord与wordList中所有的单词都加入到这个映射中，之后检查ednWord是否在该映射中。

然后，枚举每一对单词的组合，判断它们是否恰好相差一个字符，来判断这两个单词对应的节点是否能够相连。

2、代码实现

代码参考：

class Solution {
    Map<String, Integer> wordId = new HashMap<String, Integer>();
    List<List<Integer>> edge = new ArrayList<List<Integer>>();
    int nodeNum = 0;

    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        for (String word : wordList) {
            addEdge(word);
        }
        addEdge(beginWord);
        if (!wordId.containsKey(endWord)) {
            return 0;
        }
        int[] dis = new int[nodeNum];
        Arrays.fill(dis, Integer.MAX_VALUE);
        int beginId = wordId.get(beginWord), endId = wordId.get(endWord);
        dis[beginId] = 0;

        Queue<Integer> que = new LinkedList<Integer>();
        que.offer(beginId);
        while (!que.isEmpty()) {
            int x = que.poll();
            if (x == endId) {
                return dis[endId] / 2 + 1;
            }
            for (int it : edge.get(x)) {
                if (dis[it] == Integer.MAX_VALUE) {
                    dis[it] = dis[x] + 1;
                    que.offer(it);
                }
            }
        }
        return 0;
    }

    public void addEdge(String word) {
        addWord(word);
        int id1 = wordId.get(word);
        char[] array = word.toCharArray();
        int length = array.length;
        for (int i = 0; i < length; ++i) {
            char tmp = array[i];
            array[i] = '*';
            String newWord = new String(array);
            addWord(newWord);
            int id2 = wordId.get(newWord);
            edge.get(id1).add(id2);
            edge.get(id2).add(id1);
            array[i] = tmp;
        }
    }

    public void addWord(String word) {
        if (!wordId.containsKey(word)) {
            wordId.put(word, nodeNum++);
            edge.add(new ArrayList<Integer>());
        }
    }
}

3、时间复杂度

时间复杂度：O(N X C²)

其中N为wordList的长度，C为列表中单词的长度。

空间复杂度：O(N X C²)

其中N为wordList的长度，C为列表中单词的长度。哈希表中包含O(N X C)个节点，每个节点占用空间为O©，因此总时间复杂度为O(N X C²)。

三、总结

广度优先搜索的搜索空间依赖于每层节点的分支数量。

假如每个节点的分支数量相同，那么搜索空间会随着层数的增长指数级增加，节点的数量会以2为底数呈指数增长。

所以，可以使用双向广度优先搜索算法，一边从beginWord开始，一边从endWord开始。

然后每次从两边各自拓展一层节点，当发现某一时刻两边都访问过同一顶点的时候就停止搜索。

可以减少搜索空间大小，提高代码运行效率。