LeetCode 127. Word Ladder

原题链接在这里：https://leetcode.com/problems/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.

题解：

用BFS找最短路径。先把beginWord放入queue中，level 设值为1. 在queue不为空的情况下，从queue中拿出一个word, 设为cur, 同时curCount--.

从cur的第一个字母开始，从a 到 z 挨个替换，若是等于了endWord, 直接返回level+1即可。否则就看set 中是否有这个变形，若是有就把他添加到queue中，并增加计数nextCount. 为了保证不陷入infinite loop, 需同时从set中remove掉这个词。

每当curCont == 0时，说明本层已经扫描完，level++, 同时更新curCount 为nextCount, nextCount 为 0.

Time Complexity: O(m*n). m = wordList.size(). n = beginWord.length().

Space: O(m*n). queue把所有的word都加了进去.

AC Java:

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        if(wordList == null || wordList.size() == 0){
            return 0;
        }
        
        HashSet<String> dic = new HashSet<>();
        dic.addAll(wordList);
        
        if(!dic.contains(endWord)){
            return 0;
        }
        
        int level = 1;
        LinkedList<String> que = new LinkedList<>();
        que.add(beginWord);
        while(!que.isEmpty()){
            int size = que.size();
            
            while(size-- > 0){
                String cur = que.poll();
                if(cur.equals(endWord)){
                    return level;
                }
                
                for(int i = 0; i < cur.length(); i++){
                    char [] arr = cur.toCharArray();
                    char ori = arr[i];
                    for(char k = 'a'; k <= 'z'; k++){
                        if(ori == k){
                            continue;
                        }
                        
                        arr[i] = k;
                        String can = new String(arr);
                        if(dic.contains(can)){
                            dic.remove(can);
                            que.add(can);
                        }
                    }
                }
            }
            
            level++;
        }
        
        return 0;
    }
}

Could optimize with bidirectional BFS.

Time Complexity: O(m * n). m = wordList.size(). n = word.length().

Space: O(m * n).

AC Java:

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        if(wordList == null || wordList.size() == 0){
            return 0;
        }
        
        HashSet<String> dic = new HashSet<>();
        dic.addAll(wordList);
        
        if(!dic.contains(endWord)){
            return 0;
        }
        
        HashSet<String> startSet = new HashSet<String>();
        startSet.add(beginWord);
        HashSet<String> endSet = new HashSet<String>();
        endSet.add(endWord);
        HashSet<String> visited = new HashSet<String>();
        visited.add(beginWord);
        
        int level = 1;
        while(!startSet.isEmpty()){
            if(startSet.size() > endSet.size()){
                HashSet<String> temp = startSet;
                startSet = endSet;
                endSet = temp;
            }
            
            HashSet<String> nextSet = new HashSet<String>();
            for(String cur : startSet){
                for(int i = 0; i < cur.length(); i++){
                    char [] arr = cur.toCharArray();
                    char ori = arr[i];
                    for(char k = 'a'; k <= 'z'; k++){
                        if(k == ori){
                            continue;
                        }
                        
                        arr[i] = k;
                        String can = new String(arr);
                        if(endSet.contains(can)){
                            return level + 1;
                        }
                        
                        if(dic.contains(can) && visited.add(can)){
                            nextSet.add(can);
                        }
                    }
                }
            }
            
            startSet = nextSet;
            level++;
        }
        
        return 0;
    }
}

跟上Word Ladder II.

Reference: http://www.cnblogs.com/springfor/p/3893499.html