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:

Only one letter can be changed at a time
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"]
  ]

Leetcode 里面通过概率最低的一道题，参看了别人的解法：利用bfs 层序遍历 如果队列中有end 那么结束遍历（到最短的一层就结束）

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;

public class Solution {
    class WordWithLevel {
        String word;
        int level;

        public WordWithLevel(String word, int level) {
            this.word = word;
            this.level = level;
        }
    }

    private String end;
    private ArrayList<ArrayList<String>> result;
    private Map<String, List<String>> nextMap;

    public ArrayList<ArrayList<String>> findLadders(String start, String end,
            HashSet<String> dict) {
        result = new ArrayList<ArrayList<String>>();
        this.end = end;

        // unvisited words set
        Set<String> unVisited = new HashSet<String>();
        unVisited.addAll(dict);
        unVisited.add(start);
        unVisited.remove(end);

        // used to record the map info of <word : the words of next level>
        nextMap = new HashMap<String, List<String>>();
        for (String e : unVisited) {
            nextMap.put(e, new ArrayList<String>());
        }

        // BFS to search from the end to start
        Queue<WordWithLevel> queue = new LinkedList<WordWithLevel>();
        queue.add(new WordWithLevel(end, 0));
        boolean found = false;
        int finalLevel = Integer.MAX_VALUE;
        int currentLevel = 0;
        int preLevel = 0;
        Set<String> visitedWordsInThisLevel = new HashSet<String>();
        while (!queue.isEmpty()) {
            WordWithLevel wordWithLevel = queue.poll();
            String word = wordWithLevel.word;
            currentLevel = wordWithLevel.level;
            if (found && currentLevel > finalLevel) {
                break;
            }
            if (currentLevel > preLevel) {
                unVisited.removeAll(visitedWordsInThisLevel);
            }
            preLevel = currentLevel;
            char[] wordCharArray = word.toCharArray();
            for (int i = 0; i < word.length(); ++i) {
                char originalChar = wordCharArray[i];
                boolean foundInThisCycle = false;
                for (char c = 'a'; c <= 'z'; ++c) {
                    wordCharArray[i] = c;
                    String newWord = new String(wordCharArray);
                    if (c != originalChar && unVisited.contains(newWord)) {
                        nextMap.get(newWord).add(word);
                        if (newWord.equals(start)) {
                            found = true;
                            finalLevel = currentLevel;
                            foundInThisCycle = true;
                            break;
                        }
                        if (visitedWordsInThisLevel.add(newWord)) {
                            queue.add(new WordWithLevel(newWord,
                                    currentLevel + 1));
                        }
                    }
                }
                if (foundInThisCycle) {
                    break;
                }
                wordCharArray[i] = originalChar;
            }
        }

        if (found) {
            // dfs to get the paths
            ArrayList<String> list = new ArrayList<String>();
            list.add(start);
            getPaths(start, list, finalLevel + 1);
        }
        return result;
    }

    private void getPaths(String currentWord, ArrayList<String> list, int level) {
        if (currentWord.equals(end)) {
            result.add(new ArrayList<String>(list));
        } else if (level > 0) {
            List<String> parentsSet = nextMap.get(currentWord);
            for (String parent : parentsSet) {
                list.add(parent);
                getPaths(parent, list, level - 1);
                list.remove(list.size() - 1);
            }
        }
    }
}

自己的解法还需要多想想：

public class Solution {
    public ArrayList<ArrayList<String>> findLadders(String start, String end, Set<String> dict) {
        ArrayList<String> Ladder=new ArrayList<String>();
        ArrayList<ArrayList<String>> LadderList=new ArrayList<ArrayList<String>>();
        if(start.length() != end.length()) return LadderList;
        shortestladders(start, end, dict, Ladder, LadderList);
        return LadderList;
    }
    
    public void shortestladders(String start, String end, Set<String> dict, ArrayList<String> Ladder, ArrayList<ArrayList<String>> LadderList){
        Ladder.add(start);
        if(within(start, end)) { //end is only 1 bit different from start
            Ladder.add(end);
            if(LadderList.isEmpty()) { //LadderList is empty, so Ladder is definately shortest
                LadderList.add(Ladder);
            }
            else { //LadderList is not empty, so need comparition
                ArrayList<String> shortestLadder = LadderList.get(0); // select one from LadderList
                if(Ladder.size() < shortestLadder.size()) { //new found Ladder is shorter than LadderList
                    LadderList.clear();
                    LadderList.add(Ladder);
                }
                else if(Ladder.size() == shortestLadder.size()) { //new found Ladder is the same with the LadderList,add to Ladderlist
                    LadderList.add(Ladder);
                }
                // new found Ladder is longer than elems in LadderList, so do not change LadderList
            }
            Ladder.remove(Ladder.size()-1); //remove end
        }
        
        else { //end is more than 1 bit different from start, so look for temp elems in dict which is 1 bit different from start
            if(!dict.isEmpty()) {
                for(String temp:dict){
                    if(within(start, temp)){
                        dict.remove(start);
                        shortestladders(temp, end, dict, Ladder, LadderList);
                        dict.add(start);
                    }
                }
            }
   
        }
        Ladder.remove(Ladder.size()-1); //remove start
    }
    
    public boolean within(String first, String second){
        int diff=0;
        for(int k=0; k<first.length(); k++){
            if(first.charAt(k)!=second.charAt(k)){
                diff++;
            }
        }
        if(diff==1) return true;
        else return false;
    }
}