LeetCode-Word Ladder

Given two words (start and end), and a dictionary, find the length of shortest transformation sequence 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"]

As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

Note:

• Return 0 if there is no such transformation sequence.
• All words have the same length.
• All words contain only lowercase alphabetic characters.

Solution (Double direct BFS):

public class Solution {
    public int ladderLength(String start, String end, Set<String> dict) {
        //Double direct BFS
        List<String> list1 = new ArrayList<String>();
        Map<String,Integer> set1 = new HashMap<String,Integer>();
        List<String> list2 = new ArrayList<String>();
        Map<String,Integer> set2 = new HashMap<String,Integer>();
        int index1 = 0;
        int index2 = 0;
        list1.add(start);
        list2.add(end);
        set1.put(start,1);
        set2.put(end,1);
        String curStr1, curStr2;
        String interStr="";
        while (true){
            boolean find = false;
            
            //No solution
            if (index1>=list1.size())
               return 0;
            
            curStr1 = list1.get(index1);
            for (int i=0;i<curStr1.length();i++){
                char array[] = curStr1.toCharArray();
                for (array[i]='a';array[i]<='z';array[i]++){
                    String temp = new String(array);
                    if (set1.containsKey(temp)) continue;
                    if (dict.contains(temp)){
                        list1.add(temp);
                        set1.put(temp,set1.get(curStr1)+1);
                        
                        if (set2.containsKey(temp)){
                            interStr = temp;
                            find = true;
                            break;
                        }
                    }
                }
            }
            index1++;
            if (find)
                break;
            
            if (index2>=list2.size())
                return 0;
                
            curStr2 = list2.get(index2);
            for (int i=0;i<curStr2.length();i++){
                char array[] = curStr2.toCharArray();
                for (array[i]='a';array[i]<='z';array[i]++){
                    String temp = new String(array);
                    if (set2.containsKey(temp)) continue;
                    if (dict.contains(temp)){
                        list2.add(temp);
                        set2.put(temp,set2.get(curStr2)+1);
                        
                        if (set1.containsKey(temp)){
                            interStr = temp;
                            find = true;
                            break;
                        }
                    }
                }
            }
           
            
            index2++;
            if (find)
                break;
        }
        
        
        //Add path from pos direct
        int dis = 0;
        dis += set1.get(interStr);
        dis += set2.get(interStr);
        dis--;
        
        return dis;
    }
    
    
   
}