LeetCode 126 词语接龙2 （搜索 java）

跟上一题127一样，但是额外要求要输出搜索的路径，而且是 所有的路径

所以需要考虑将路径转换为有向图，然后将有向图中的最短路径全部枚举出来

graph的话我们通过map<string,list<string>>来记录节点和从节点出发可以到达的其他节点，

 

class Solution {
    public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
             int L = beginWord.length();
        // preprocessing for the intermediate words
        // the adjacency map provides the adjacent words index for the words in wordList
        Map<Integer, List<Integer>> neighbors = new HashMap<>();
        List<String> newWordList = new ArrayList<>();
        newWordList.add(beginWord);
        for (String word : wordList) {
            if (!word.equals(beginWord)) {
                newWordList.add(word);
            }
        }
        Map<String, Integer> wordDict = new HashMap<>();
        for (int i = 0; i < newWordList.size(); i ++) {
            wordDict.put(newWordList.get(i), i);
            neighbors.put(i, new ArrayList<>());
        }
        for (int i = 0; i < newWordList.size(); i ++) {
            for (int j = 0; j < L; j++) {
                char[] chars = newWordList.get(i).toCharArray();
                for (char c = 'a'; c <= 'z'; c++) {
                    chars[j] = c;
                    String newWord = new String(chars);
                    if (wordDict.containsKey(newWord) && i != wordDict.get(newWord)) {
                        List<Integer> adjacencies = neighbors.get(i);
                        adjacencies.add(wordDict.get(newWord));
                    }
                }
            }
        }
        List<List<String>> result = new ArrayList<>();
        // end index
        int end = newWordList.indexOf(endWord);
        // corner case
        if (end == 0 || end == -1) return result;
        // bfs
        Map<Integer, Integer> ladders = new HashMap<>();
        bfs(neighbors, ladders, end);
        // dfs
        List<String> solution = new ArrayList<>();
        dfs(newWordList, neighbors, solution, result, ladders, 0, end);
        return result;
    }
    // breadth first search
    private void bfs( Map<Integer, List<Integer>> neighbors, Map<Integer, Integer> ladders, int end) {
        Queue<Integer> Q = new LinkedList<>();
        boolean reachEnd =false;
        Q.add(0);
        ladders.put(0, 1);
        while (!reachEnd && end != -1 && !Q.isEmpty()) {
            int size = Q.size();
            for (int i = 0; i < size; i ++) {
                Integer cur = Q.poll();
                if (cur == end) reachEnd = true;
                for (Integer next  : neighbors.get(cur)) {
                    if (!ladders.containsKey(next)) {
                        Q.add(next);
                        ladders.put(next, ladders.get(cur) + 1);
                    }
                }
            }
        }
        
    }

    
    private void dfs(List<String> newWordList, Map<Integer, List<Integer>> neighbors, List<String> solution, List<List<String>> result, Map<Integer, Integer> ladders, int cur, int end) {
        solution.add(newWordList.get(cur));
        if (cur == end) {
            result.add(new ArrayList<>(solution));
        } else {
            for (int next : neighbors.get(cur)){
                if (ladders.containsKey(next) && ladders.get(next) == ladders.get(cur) + 1) {
                    dfs(newWordList, neighbors, solution, result, ladders, next, end);
                }
            }
        }
        solution.remove(solution.size() - 1);
    }
}

 这个题感觉太难了，

 先这样放着吧，还是126简单

这个代码是复制别人提交的东西