JAVA学习-练习试用Java实现“单词接龙 II”

问题：

按字典 wordList 完成从单词 beginWord 到单词 endWord 转化，一个表示此过程的 转换序列 是形式上像 beginWord -> s1 -> s2 -> ... -> sk 这样的单词序列，并满足：

每对相邻的单词之间仅有单个字母不同。
转换过程中的每个单词 si（1 <= i <= k）必须是字典 wordList 中的单词。注意，beginWord 不必是字典 wordList 中的单词。
sk == endWord
给你两个单词 beginWord 和 endWord ，以及一个字典 wordList 。请你找出并返回所有从 beginWord 到 endWord 的 最短转换序列 ，如果不存在这样的转换序列，返回一个空列表。每个序列都应该以单词列表 [beginWord, s1, s2, ..., sk] 的形式返回。

示例 1：

输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
输出：[["hit","hot","dot","dog","cog"],["hit","hot","lot","log","cog"]]
解释：存在 2 种最短的转换序列：
"hit" -> "hot" -> "dot" -> "dog" -> "cog"
"hit" -> "hot" -> "lot" -> "log" -> "cog"
示例 2：

输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
输出：[]
解释：endWord "cog" 不在字典 wordList 中，所以不存在符合要求的转换序列。
提示：

1 <= beginWord.length <= 7
endWord.length == beginWord.length
1 <= wordList.length <= 5000
wordList[i].length == beginWord.length
beginWord、endWord 和 wordList[i] 由小写英文字母组成
beginWord != endWord
wordList 中的所有单词互不相同

解答思路：

一、题目分析：本题要求找出从起始单词到结束单词的所有最短转换序列，转换过程中每个单词与相邻单词仅有单个字母不同，且转换过程中的单词必须在给定的字典中。

二、主要思路：
1. 构建一个无向图，其中节点表示单词，边表示单词之间的转换关系。
2. 使用广度优先搜索（BFS）遍历图，找到从起始单词到结束单词的最短路径。
3. 在 BFS 过程中，记录每个节点的前驱节点，以便回溯得到转换序列。

三、以下是修改后的 Java 代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;

public class WordLadderII {

    public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
        List<List<String>> result = new ArrayList<>();
        Set<String> wordSet = new HashSet<>(wordList);
        if (!wordSet.contains(endWord)) {
            return result;
        }

        Map<String, List<String>> graph = buildGraph(beginWord, endWord, wordSet);
        Map<String, String> predecessorMap = new HashMap<>();
        Queue<String> queue = new LinkedList<>();
        queue.offer(beginWord);
        predecessorMap.put(beginWord, null);

        while (!queue.isEmpty()) {
            int size = queue.size();
            boolean found = false;

            for (int i = 0; i < size; i++) {
                String currentWord = queue.poll();

                for (String nextWord : graph.get(currentWord)) {
                    if (!predecessorMap.containsKey(nextWord)) {
                        queue.offer(nextWord);
                        predecessorMap.put(nextWord, currentWord);

                        if (nextWord.equals(endWord)) {
                            found = true;
                        }
                    }
                }
            }

            if (found) {
                break;
            }
        }

        if (predecessorMap.containsKey(endWord)) {
            List<String> path = new ArrayList<>();
            String currentWord = endWord;

            while (currentWord!= null) {
                path.add(0, currentWord);
                currentWord = predecessorMap.get(currentWord);
            }

            result.add(path);
        }

        return result;
    }

    private Map<String, List<String>> buildGraph(String beginWord, String endWord, Set<String> wordSet) {
        Map<String, List<String>> graph = new HashMap<>();

        for (String word : wordSet) {
            graph.put(word, new ArrayList<>());
        }

        for (String word : wordSet) {
            for (int i = 0; i < word.length(); i++) {
                String pattern = word.substring(0, i) + "*" + word.substring(i + 1);

                for (String neighbor : graph.get(pattern)) {
                    if (isOneLetterDifference(word, neighbor)) {
                        graph.get(word).add(neighbor);
                        graph.get(neighbor).add(word);
                    }
                }
            }
        }

        return graph;
    }

    private boolean isOneLetterDifference(String word1, String word2) {
        int differenceCount = 0;

        for (int i = 0; i < word1.length(); i++) {
            if (word1.charAt(i)!= word2.charAt(i)) {
                differenceCount++;
            }
        }

        return differenceCount == 1;
    }

    public static void main(String[] args) {
        String beginWord = "hit";
        String endWord = "cog";
        List<String> wordList = Arrays.asList("hot", "dot", "dog", "lot", "log", "cog");

        WordLadderII solution = new WordLadderII();
        List<List<String>> result = solution.findLadders(beginWord, endWord, wordList);

        for (List<String> path : result) {
            System.out.println(path);
        }
    }
}

(文章为作者在学习java过程中的一些个人体会总结和借鉴，如有不当、错误的地方，请各位大佬批评指正，定当努力改正，如有侵权请联系作者删帖。)