【Leetcode】Word Ladder I

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.

Java:

1. http://blog.csdn.net/linhuanmars/article/details/23029973

图 广度优先 

public class Solution {
     public int ladderLength(String start, String end,
            HashSet<String> dict) {
            if(start==null||end==null||start.length()==0||end.length()==0||start.length()!=end.length()) return 0;
            LinkedList<String> queue= new LinkedList<String>();
            HashSet<String> visited= new HashSet<String>();
            int level=1;
            int lastNum=1;
            int curNum=0;
            queue.offer(start);
            visited.add(start);
            while(!queue.isEmpty())
            {
                String cur=queue.poll();
                lastNum--;
                for(int i=0;i<cur.length();i++)
                {
                    char[] charCur=cur.toCharArray();
                    for(char c='a';c<='z';c++)
                    {
                        charCur[i]=c;
                        String temp=new String(charCur);
                        if(temp.equals(end)) return level+1;
                        if(dict.contains(temp)&&!visited.contains(temp))
                        {
                            curNum++;
                            queue.offer(temp);
                            visited.add(temp);
                        }
                    }
                    
                    
                }
                if(lastNum==0)
                {
                    lastNum=curNum;
                    curNum=0;
                    level++;
                }
            }
            return 0;
            }
}

2. http://www.cnblogs.com/feiling/p/3325851.html

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;
    }
}