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"]
  ]

Analysis:

BFS. store all shortest path to each node. Wheneven, generate a neighbor node from current node, determine whether it is in dict and in queue. If in queue, then determine whether the path from src to current node then to it has the same length with the already generated path of this neighbor node, if yes, then add all the new paths from src to current node to neighbor into the path set of the neighbor node.

Solution:

public class Solution {
    public List<List<String>> findLadders(String start, String end, Set<String> dict) {
        List<List<String>> res = new ArrayList<List<String>>();
        List<String> nodeList = new ArrayList<String>();
        List<Integer> levelList = new ArrayList<Integer>();
        Map<String,List<List<String>>> resSet = new HashMap<String,List<List<String>>>();

        nodeList.add(start);
        levelList.add(1);
        List<List<String>> nodeRes = new ArrayList<List<String>>();
        List<String> onePath = new ArrayList<String>();
        onePath.add(start);
        nodeRes.add(onePath);
        resSet.put(start,nodeRes);        

        int cur = 0;
        boolean findEnd = false;
        while (cur<nodeList.size()){
            int curLevel = levelList.get(cur);         
            while (cur<nodeList.size() && levelList.get(cur)==curLevel){
                String curNode = nodeList.get(cur);                
                nodeRes = resSet.get(curNode);
                for (int i=0;i<curNode.length();i++)
                    for (int j=0;j<26;j++){
                        char[] temp = curNode.toCharArray();
                        temp[i] = (char) ('a'+j);                      
                        String newNode = new String(temp);
                        if (dict.contains(newNode) && !resSet.containsKey(newNode)){
                            nodeList.add(newNode);
                            levelList.add(curLevel+1);
                            List<List<String>> newRes = new ArrayList<List<String>>();
                            for (int k=0;k<nodeRes.size();k++){
                                onePath = new ArrayList<String>();
                                onePath.addAll(nodeRes.get(k));
                                onePath.add(newNode);
                                newRes.add(onePath);
                            }
                            resSet.put(newNode,newRes);                            
                        } else if (dict.contains(newNode) && resSet.containsKey(newNode) && nodeRes.get(0).size()+1<=resSet.get(newNode).get(0).size()){
                            List<List<String>> newRes = resSet.get(newNode);
                            for (int k=0;k<nodeRes.size();k++){
                                onePath = new ArrayList<String>();
                                onePath.addAll(nodeRes.get(k));
                                onePath.add(newNode);
                                newRes.add(onePath);
                            }                            
                        }

                        if (newNode.equals(end)){                            
                            findEnd = true;
                        }
                    }
                cur++;
            } 
            if (findEnd) break;
        } 
        
        if (!findEnd)
            return (new ArrayList<List<String>>());
        else return resSet.get(end);
    }
}