LeetCode 25 Word Ladder II

Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) from start to end, such that:

1, Only one letter can be changed at a time

2, Each intermediate word must exist in the dictionary

For example,

Given:

start = "hit"

end = "cog"

dict = [ "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.

分析：

看到单词换字母，想到的是图，一个单词每换一个字母，就生成一个相邻节点，

看到最短路径，想到BFS，BFS可以确保搜索到的一定是最短路径，

要输出最短路径，BFS之后就要从后往前原路返回，

要输出所有最短路径，则每一个节点要维护一个所有前驱节点的list，

要判断是不是前驱节点，则每一个节点要维护一个距离，

BFS的话，就要标记是否访问过，这个应该用个Hash，应为需要通过word访问node，所以应该用HashMap，

基于以上考虑，一个节点要保存所代表的word，要保存离开始节点的距离，要保存一个前驱节点的list.

感觉这个题信息量略大啊。。。

public class Solution {
    
    class Node{
        public int dist;
        public String str;
        public LinkedList<Node> prev;
        
        public Node(int dist, String str){
            this.dist = dist;
            this.str = str;
            this.prev = new LinkedList<Node>();
        }
        
        public void addPrev(Node pNode){
            prev.add(pNode);
        }
    }
    
    public List<List<String>> findLadders(String start, String end, Set<String> dict) {
        //因为对dict里的word建立图关系，所以要把end加到字典里先
        dict.add(end);
        //Node可以存放更多信息，利用HashMap可以最快通过word访问到相对应的node
        Map<String, Node> map = new HashMap<String, Node>();
        //广度优先遍历当然用到队列
        Queue<String> queue = new LinkedList<String>();
        
        Node startNode = new Node(1, start);
        queue.offer(start);
        map.put(start, startNode);
        
        List<List<String>> ret = new ArrayList<List<String>>();
        //开始遍历
        while(!queue.isEmpty()){
            //出队当前节点
            String str = queue.poll();
            //找到了，开始生成路径，不需要再寻找下去
            if(str.equals(end)){
                getPaths(map.get(end), map, new ArrayList<String>(), ret);
                return ret;
            }
            //尝试str变体的所有可能,每一个位置都尝试所有26个字母
            for(int i=0; i<str.length(); i++){
                for(int j=0; j<26; j++){
                    //生成新的单词
                    String newStr = replace(str, i, (char)('a'+j));
                    //如果生成的新单词不再字典里，就不再考虑了
                    if(dict.contains(newStr)){
                        //在字典里，并且没有访问过
                        if(!map.containsKey(newStr)){
                            Node node = map.get(str);
                            //新建节点，距离比前驱加1
                            Node newNode = new Node(node.dist+1, newStr);
                            newNode.prev = new LinkedList<Node>();
                            //加入前驱节点
                            newNode.prev.add(node);
                            //建立Hash关系
                            map.put(newStr, newNode);
                            //入队，参加BFS
                            queue.offer(newStr);
                        }else{
                            //已经访问过，则要检查能不能建立图关系
                            Node node = map.get(newStr);
                            Node prevNode = map.get(str);
                            //如果满足距离关系，应该加一条边，即加入前驱list
                            if(node.dist == prevNode.dist+1){
                                node.addPrev(prevNode);
                            }
                        }
                    }
                }
            }
        }
        return ret;
    }
    //替换字符生成新单词的辅助函数
    private String replace(String str, int index, char c){
        StringBuilder sb = new StringBuilder(str);
        sb.setCharAt(index, c);
        return sb.toString();
    }
    //根据图关系，生成路径
    private void getPaths(Node end, Map<String, Node> map, ArrayList<String> curPath, List<List<String>> paths){
        if(end == null){
            paths.add(curPath);
            return;
        }
        curPath.add(0, end.str);
        if(!end.prev.isEmpty()){
            //递归
            for(Node prevNode : end.prev){
                //记住每一次都要重新new一个
                getPaths(prevNode, map, new ArrayList<String>(curPath), paths);
            }
        }else{
            getPaths(null, map, curPath, paths);
        }
    }
}