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.

bug code

public class Solution {
    public int ladderLength(String start, String end, HashSet<String> dict) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if(dict.size() == 0 || start.equals(end)){
            return 0;
        }
        //dict.add(start);
        dict.remove(start);
        dict.add(end);
        int result = getLen(start, end, dict, 0);
        if(result == 0){
            return result;
        } 
        return result + 1; 
    }
    
    public int getLen(String start, String end, HashSet<String> dict, int len){
        if(start.equals(end)){
            return len;
        }
        
        HashSet<String> neighbors = getNeighbors(start, dict);
        int maxLen = len;
        for(String n : neighbors){
            dict.remove(n);
            int tmp = getLen(n, end, dict, len + 1);
            if(tmp > maxLen){
                maxLen = tmp;
            }
            dict.add(n);
        }
        return maxLen;
    }
    
    public HashSet<String> getNeighbors(String start, HashSet<String> dict){
        HashSet<String> result = new HashSet<String>();
        for(int i = 0; i < start.length(); i++){
            StringBuffer sb = new StringBuffer();
            if(i == 1){
                sb.append(start.substring(0, 1));
            } else if(i == 0){
                
            } else {
                sb.append(start.substring(0, i));
            }
            for(char c = 'a'; c <= 'z'; c++){
                if(c != start.charAt(i)){
                    sb.append(c).append(start.substring(i + 1));
                    if(dict.contains(sb.toString())){
                        result.add(sb.toString());
                    }
                }
            }
        }
        return result;
    }
}

BFS

类似于图的遍历，将start一步内可以到达的单词加入到queue中，并将相应长度放入queue中

每次从queue中poll出一个单词，看是否是目标单词，如果是则返回相应长度

对每个单词的每一位进行变化('a'-'z'), 看是否在dict中，如在则说明该单词是转换路径中的一个

由于在找到一个转换路径后就返回，此返回值可以确保是最小值

public class Solution {
    public static int ladderLength(String start, String end,
            HashSet<String> dict) {
        int result = 0;
        if (dict.size() == 0) {
            return result;
        }

        dict.add(start);
        dict.add(end);

        result = BFS(start, end, dict);

        return result;
    }

    private static int BFS(String start, String end, HashSet<String> dict) {
        Queue<String> queue = new LinkedList<String>();
        Queue<Integer> length = new LinkedList<Integer>();
        queue.add(start);
        length.add(1);

        while (!queue.isEmpty()) {
            String word = queue.poll();
            int len = length.poll();

            if (match(word, end)) {
                return len;
            }

            for (int i = 0; i < word.length(); i++) {
                char[] arr = word.toCharArray();
                for (char c = 'a'; c <= 'z'; c++) {
                    if (c == arr[i])
                        continue;

                    arr[i] = c;
                    String str = String.valueOf(arr);
                    if (dict.contains(str)) {
                        queue.add(str);
                        length.add(len + 1);
                        dict.remove(str);
                    }
                }
            }
        }

        return 0;
    }

    private static boolean match(String word, String end) {
        if (word.equals(end)) {
            return true;
        }
        return false;
    }
}