[leetCode]127. 单词接龙

题目

链接：https://leetcode-cn.com/problems/word-ladder

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

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

如果不存在这样的转换序列，返回 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" 不在字典中，所以无法进行转换。

广度优先搜索 + 优化建图

class Solution {
    // 给每个单词分配一个id 创建单词与id的映射
    Map<String, Integer> wordId = new HashMap<>();
    // 边集集合，下标为顶点id，值为与该顶点相连的顶点
    List<List<Integer>> edge = new ArrayList<>();
    // 图中的节点的数量
    int nodeNum = 0;

    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        // 将wordList与beginWord中的每一个单词都添加映射，并与其对应的虚拟节点双向连接
        for (String word : wordList) {
            addEdge(word);
        }
        addEdge(beginWord);
        // endWord不在映射内则无解
        if (!wordId.containsKey(endWord)) {
            return 0;
        }
        
        // 定义一个数组下标为顶点id值为从起点（beginId）到该顶点的最短路径
        int[] dis = new int[nodeNum];
        Arrays.fill(dis, Integer.MAX_VALUE);
        // 起点和终点对应的id
        int beginId = wordId.get(beginWord), endId = wordId.get(endWord);
        // 从起点到起点最短路径长度为0
        dis[beginId] = 0;
        // 广度优先搜索
        Queue<Integer> que = new LinkedList<>();
        que.offer(beginId);
        while (!que.isEmpty()) {
            int x = que.poll();
            if (x == endId) {
                return dis[endId] / 2 + 1;
            }
            // 遍历与当前顶点x相连的顶点
            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);
        // 获取当前单词的id
        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);
            // 获取当前虚拟节点的id
            int id2 = wordId.get(newWord);
            // 原有的单词对应的边的集合中添加虚拟节点的id
            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>());
        }
    }
}