126. Word Ladder II

题目：

Given two words (beginWord and endWord), and a dictionary's word list, find all shortest transformation sequence(s) from beginWord to endWord, such that:

1. Only one letter can be changed at a time
2. Each intermediate word must exist in the word list

For example,

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

Return

  [
    ["hit","hot","dot","dog","cog"],
    ["hit","hot","lot","log","cog"]
  ]

Note:

• All words have the same length.
• All words contain only lowercase alphabetic characters.

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

5/17/2017

算法班，抄答案

注意第12行，leetcode的要求是endWord需要在wordList当中。

做法是从头到位BFS算最小距离，从尾到头DFS求所有路径。

public class Solution {
    public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
        List<List<String>> ret = new ArrayList<>();
        Set<String> wordSet = new HashSet();
        for (String word: wordList) {
            wordSet.add(word);
        }
        if (!wordSet.contains(endWord)) {
            return ret;
        }
        wordSet.add(beginWord);
    //    wordSet.add(endWord);
        Map<String, List<String>> wordGraph = buildAdjacencyWords(wordSet);
        Map<String, Integer> distance = new HashMap<String, Integer>();
        bfs(wordSet, wordGraph, distance, beginWord);
        
        List<String> list = new ArrayList<String>();
        dfs(distance, beginWord, endWord, wordGraph, ret, list);
        return ret;
    }
    
    private void dfs(Map<String, Integer> distance, String start, String end, Map<String, List<String>> wordGraph, List<List<String>> ret, List<String> list) {
        list.add(end);
        if (end.equals(start)) {
            Collections.reverse(list);
            ret.add(new ArrayList<String>(list));
            Collections.reverse(list);
        } else {
            for (String neighbor: wordGraph.get(end)) {
                if (distance.containsKey(neighbor) && distance.get(end) == distance.get(neighbor) + 1) { 
                    dfs(distance, start, neighbor, wordGraph, ret, list);
                }
            }
        }
        list.remove(list.size() - 1);
    }
    
    private void bfs(Set<String> wordSet, Map<String, List<String>> wordGraph, Map<String, Integer> distance, String start) {
        Queue<String> queue = new LinkedList<String>();
        queue.offer(start);
        distance.put(start, 0);

        while (!queue.isEmpty()) {
            String s = queue.poll();
            for (String neighbor: wordGraph.get(s)) {
                if (!distance.containsKey(neighbor)) {
                    queue.offer(neighbor);
                    distance.put(neighbor, distance.get(s) + 1);
                }
            }
        }
    }
    
    private Map<String, List<String>> buildAdjacencyWords(Set<String> wordSet) {
        Map<String, List<String>> map = new HashMap<String, List<String>>();
        
        for (String word: wordSet) {
            map.put(word, new ArrayList<String>());
            for (int i = 0; i < word.length(); i++) {
                char c = word.charAt(i);
                for (char l = 'a'; l <= 'z'; l++) {
                    String other = word.substring(0, i) + l + word.substring(i + 1, word.length());
                    if (wordSet.contains(other)) {
                        map.get(word).add(other);
                    }
                }
            }
        }
        return map;
    }
}

别人的答案：

一种BFS有向图+DFS，一种是用2个set？？？

https://discuss.leetcode.com/topic/2857/share-two-similar-java-solution-that-accpted-by-oj

https://discuss.leetcode.com/topic/27504/my-concise-java-solution-based-on-bfs-and-dfs

two end BFS

https://discuss.leetcode.com/topic/17975/super-fast-java-solution-two-end-bfs

更多讨论

https://discuss.leetcode.com/category/134/word-ladder-ii