127. Word Ladder

Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:

1. Only one letter can be changed at a time.
2. Each transformed word must exist in the word list. Note that beginWord is not a transformed word.

For example,

Given:

beginWord = "hit"

endWord = "cog"

wordList = ["hot","dot","dog","lot","log","cog"]

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.
• You may assume no duplicates in the word list.
• You may assume beginWord and endWord are non-empty and are not the same.

UPDATE (2017/1/20):

The wordList parameter had been changed to a list of strings (instead of a set of strings). Please reload the code definition to get the latest changes.

求从beginWord转换到endWord的最短变换 

求最短 用bfs

    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        HashSet<String> words = new HashSet<>();
        words.addAll(wordList);
        if (!words.contains(endWord)) return 0;
        
        Queue<String> queue = new LinkedList<>();
        queue.offer(beginWord);
        int length = 1;
        while (!queue.isEmpty()) {
            Queue<String> queue2 = new LinkedList<>();
            while (!queue.isEmpty()) {
                beginWord = queue.poll();
                HashSet<String> wordsWithinDistance = getWordsWithinDistance(beginWord, words);
                if (wordsWithinDistance.contains(endWord)) return length + 1;
                queue2.addAll(wordsWithinDistance);
            }
            length ++;
            queue = queue2;
        }

        return 0;
    }
    
    private HashSet<String> getWordsWithinDistance(String word, HashSet<String> wordList) {
        HashSet<String> set = new HashSet<>();
        char[] array = word.toCharArray();
        for (int i=0; i<array.length; i++) {
            char origin = array[i];
            for (int j=0; j<26; j++) {
                char c = (char) ('a' + j);
                if (c == origin) continue;
                array[i] = c;
                String s = new String(array);
                if (wordList.remove(s)) {
                    set.add(s);
                }
            }
            array[i] = origin;
        }
        return set;
    }

discuss中有一个runtime很短的 

public int ladderLength(String beginWord, String endWord, Set<String> wordList) {
        Set<String> beginSet = new HashSet<String>(), endSet = new HashSet<String>();

        int len = 1;
        int strLen = beginWord.length();
        HashSet<String> visited = new HashSet<String>();
        
        beginSet.add(beginWord);
        endSet.add(endWord);
        while (!beginSet.isEmpty() && !endSet.isEmpty()) {
                if (beginSet.size() > endSet.size()) {
                        Set<String> set = beginSet;
                        beginSet = endSet;
                        endSet = set;
                }

                Set<String> temp = new HashSet<String>();
                for (String word : beginSet) {
                        char[] chs = word.toCharArray();

                        for (int i = 0; i < chs.length; i++) {
                                for (char c = 'a'; c <= 'z'; c++) {
                                        char old = chs[i];
                                        chs[i] = c;
                                        String target = String.valueOf(chs);

                                        if (endSet.contains(target)) {
                                                return len + 1;
                                        }

                                        if (!visited.contains(target) && wordList.contains(target)) {
                                                temp.add(target);
                                                visited.add(target);
                                        }
                                        chs[i] = old;
                                }
                        }
                }

                beginSet = temp;
                len++;
        }
        
        return 0;
}

改进点在于 他相当于从两边找 每次把size小的set作为起始set 也就是主动的去缩小搜索空间 所以很快