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.

链接：https://leetcode.com/problems/word-ladder/#/description

6/8/2017

很开始做word ladder 2时候把思路理解了，虽然Java语法有很多小错误，但是还是通过了。思路就是建立每个word的neighbor list，其中在建的过程中可以把beginWord也算进去，算完了就取出来好了。然后bfs找到最短的路径。

239ms, 22%，运行时间有点长，不过不是大问题。

注意的问题：

1. step一进入循环就要加，否则本轮退出就计算不了了

2. visited和wordNeighbor里面有beginWord是没有关系的。这样第19行可以更简洁。做法是第33和50行

3. buildNeighborMap那部分里面对每一个word的每一个位置更换26个字母

4. 每到一个新word先wordNeighbor.put(word, new ArrayList<String>())之后再wordNeighbor.get(word).add(tempString)不可以用，不知道为什么。

public class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        // build map Map<String, List<String>>
        Map<String, List<String>> wordNeighbor = buildNeighborMap(wordList, beginWord);
        // bfs
        Set<String> visited = new HashSet<String>(); // could include beginWord
        Queue<String> queue = new LinkedList<String>();
        int step = 0;
        queue.offer(beginWord);
        while (!queue.isEmpty()) {
            int size = queue.size();
            step++;
            for (int i = 0; i < size; i++) {
                String transform = queue.poll();
                if (visited.contains(transform)) {
                    continue;
                }
                visited.add(transform);
                if (transform.equals(endWord)) {
                    return step;
                }
                for (String n: wordNeighbor.get(transform)) {
                    queue.offer(n);
                }
            }
        }
        return 0;
    }
    private Map<String, List<String>> buildNeighborMap(List<String> wordList, String beginWord) {
        Map<String, List<String>> wordNeighbor = new HashMap<String, List<String>>();
        Set<String> wordSet = new HashSet<String>(wordList);
        // add beginWord, easy to find its neighbor
        wordList.add(beginWord);
        for (String word: wordList) {
            int wordLength = word.length();
            List<String> neighbors = new ArrayList<String>();
            for (int i = 0; i < wordLength; i++) {
                for (char c = 'a'; c <= 'z'; c++) {
                    StringBuilder temp = new StringBuilder(word);
                    temp.setCharAt(i, c);
                    String tempString = temp.toString();
                    if (wordSet.contains(tempString)) {
                        neighbors.add(tempString);
                    }
                }
            }
            wordNeighbor.put(word, neighbors);
        }
        // remove beginWord, since it's not a transformed word
        wordList.remove(wordList.size() - 1);
        return wordNeighbor;
    }
}

别人关于时间复杂度的理解

但是我认为时间复杂度没有那么高？？？

http://www.cnblogs.com/yrbbest/p/4438488.html

更多讨论

https://discuss.leetcode.com/category/135/word-ladder