leetcode--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.

题意：

给定两个单词（起始单词和终止单词），和一本字典。找到从起始单词到终止单词的最短转换路径。

要求：每次只能转换一个字母

    每个转换后的单词都必须在字典里面

例如”hit“为起始单词，"cog"为终止单词

字典为{"hot","dot","dog","lot","log"}

其中一条最短路径为"hot","dot","dog","lot","log"

Note： 所有的单词长度都相同

            单词中都是小写字母

分类：字符串，图，广度搜索

解法1：基本思路和Word Ladder相同。关键在于存储所有的路径。

为了存储路径，需要为每个节点增加一个pre指针指向它的前一个节点。

另外注意，在遍历某一层的时候，如果节点a找到了下一个节点next，不要马上将其从字典里面删除

因为这一层的某个节点b，也可能下一层节点也是它next。

如果你删除了，那么这个b就找不到next了，而这也是一条路径。

所以合适的做法是，当这一层全部遍历完，我们才删除已经访问过的下一层节点。

这就需要我们记录下一层访问过的节点，在代码里面我们用visited来记录。

public class Solution {
    public List<List<String>> findLadders(String start, String end, Set<String> dict) {
        class WordNode{//这个类用于标记单词位于广度搜索的哪一层  
            String word;  
            int step;  
            WordNode pre;
            public WordNode(String word, int step,WordNode pre) {  
                this.word = word;  
                this.step = step;  
                this.pre = pre;
            }                         
        }         
        
        ArrayList<List<String>> res = new ArrayList<List<String>>();
        dict.add(end);
        HashSet<String> visited = new HashSet<String>();//用于标记下一层已经访问过的节点
        HashSet<String> unvisited = new HashSet<String>();//用于标记还没有访问的节点
        unvisited.addAll(dict);
        Queue<WordNode> queue = new LinkedList<WordNode>();//队列  
        queue.add(new WordNode(start,1,null));//起始单词加入队列  
        int preNumSteps = 0;//队列中上一个节点所在的层
        int minStep = 0;//最短路径长度
        
        while(!queue.isEmpty()){
            WordNode cur = queue.poll();  
            int currNumSteps = cur.step;
            if(cur.word.equals(end)){//判断是否是终止单词
                if(minStep == 0){//判断是否第一次找到最短路径
                    minStep = cur.step;//更新最短路径
                }
 
                if(cur.step == minStep && minStep !=0){//如果是最短路径，添加结果
                    ArrayList<String> t = new ArrayList<String>();
                    t.add(cur.word);
                    while(cur.pre !=null){
                        t.add(0, cur.pre.word);
                        cur = cur.pre;
                    }
                    res.add(t);
                    continue;
                }
            }  
            if(preNumSteps < currNumSteps){//说明这是下一层的开始，这时可以清空所有的访问过的节点
                unvisited.removeAll(visited);
            }
            preNumSteps = currNumSteps;
            char[] arr = cur.word.toCharArray();  
            for(int i=0;i<arr.length;i++){//遍历单词每个字母  
                for(int c='a';c<='z';c++){//更换  
                    char temp = arr[i];  
                    if(c!=temp){  
                        arr[i] = (char) c;  
                    }
                    String str = new String(arr);  
                    if(unvisited.contains(str)){//判断变换后的单词是不是在字典里面  
                        queue.add(new WordNode(str, currNumSteps+1,cur));//加入队列  
                        visited.add(str);//从字典中移除  
                    }  
                    arr[i] = temp;//恢复原单词  
                }  
            }  
        }
        return res;
    }
}