126. Word Ladder II

思路是清晰的：

从beginword开始用BFS给所有单词标记深度。       

注意如图的情况，level2的节点在标记深度的时候候选点都有4号节点，标记的时候如果此次标记能够将4号深度变浅，应尽量变浅。

标记的过程中对每一个单词维护一个表，用于记录【上一层】的所有节点，方便回溯寻找路径，否则使用dfs再次搜索，复杂度将是指数级

找和当前单词差一个字母的单词的时候使用变换法，在每一个位上去改变字母，再检测新单词是否存在于表中来代替在单词表中遍历，单词表巨大的时候能提高效率。

代码摘自：

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

 Map<String,List<String>> map;
    List<List<String>> results;
    
    
    public List<List<String>> findLadders(String beginWord, String endWord, Set<String> wordList)
    {  
        String start=beginWord;
        String end=endWord;
        Set<String> dict=wordList;
        results= new ArrayList<List<String>>();
        if (dict.size() == 0)
            return results;

        int min=Integer.MAX_VALUE;

        Queue<String> queue= new ArrayDeque<String>();
        queue.add(start);

        map = new HashMap<String,List<String>>();

        Map<String,Integer> ladder = new HashMap<String,Integer>();
        for (String string:dict)
            ladder.put(string, Integer.MAX_VALUE);
        ladder.put(start, 0);

        dict.add(end);
     
        while (!queue.isEmpty()) 
        {

            String word = queue.poll();

            int step = ladder.get(word)+1;

            if (step>min) break;

            for (int i = 0; i < word.length(); i++)
            {
               StringBuilder builder = new StringBuilder(word); 
                for (char ch='a';  ch <= 'z'; ch++){
                    builder.setCharAt(i,ch);
                    String new_word=builder.toString();             
                    if (ladder.containsKey(new_word))
                    {

                        if (step>ladder.get(new_word))
                            continue;
                        else if (step<ladder.get(new_word))
                        {
                            queue.add(new_word);
                            ladder.put(new_word, step);
                        }else;
                        if (map.containsKey(new_word)) 
                            map.get(new_word).add(word);
                        else{
                            List<String> list= new LinkedList<String>();
                            list.add(word);
                            map.put(new_word,list);
                       
                        }

                        if (new_word.equals(end))
                            min=step;

                    }
                }
            }
        }

   
        LinkedList<String> result = new LinkedList<String>();
        backTrace(end,start,result);

        return results;        
    }
    
        private void backTrace(String word,String start,List<String> list)
        {
            if (word.equals(start))
            {
                list.add(0,start);
                results.add(new ArrayList<String>(list));
                list.remove(0);
                return;
            }
            list.add(0,word);
            if (map.get(word)!=null)
                for (String s:map.get(word))
                    backTrace(s,start,list);
            list.remove(0);
        }