LeetCode 126. Word Ladder II

原题链接在这里：https://leetcode.com/problems/word-ladder-ii/

题目：

Given two words (beginWord and endWord), and a dictionary's word list, find all shortest transformation sequence(s) 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"]

Return

  [
    ["hit","hot","dot","dog","cog"],
    ["hit","hot","lot","log","cog"]
  ]

Note:

• Return an empty list 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.

Use BFS to construct a map. In this map, each word has corresponding set of next available words.

When done with current set of words, need to remvoe them from set. Otherwise it would come back.

再用DFS打印路径.

Time Complexity: O(m*n). m = WordList.size(). n是平均word的长度. DFS 与BFS用时相似.

Space: O(m).

AC Java:

class Solution {
    public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
        List<List<String>> res = new ArrayList<>();
        if(beginWord == null || endWord == null){
            return res;
        }
        
        HashSet<String> dic = new HashSet<>(wordList);
        if(!dic.contains(endWord)){
            return res;
        }
        
        HashMap<String, HashSet<String>> wordToCloest = new HashMap<>();
        HashSet<String> curSet = new HashSet<>();
        curSet.add(beginWord);
        bfs(curSet, endWord, wordToCloest, dic);
        
        List<String> item = new ArrayList<String>();
        item.add(beginWord);
        dfs(beginWord, endWord, wordToCloest, item, res);
        return res;
    }
    
    private void bfs(HashSet<String> curSet, String endWord, HashMap<String, HashSet<String>> wToClo, HashSet<String> dic){
        if(curSet == null || curSet.size() == 0){
            return;
        }
        
        dic.removeAll(curSet);
        boolean isEnd = false;
        HashSet<String> nextSet = new HashSet<>();
        for(String cur : curSet){            
            for(int i = 0; i < cur.length(); i++){
                char [] arr = cur.toCharArray();
                char ori = arr[i];
                for(char c = 'a'; c <= 'z'; c++){
                    if(ori == c){
                        continue;
                    }
                    
                    arr[i] = c;
                    String can = new String(arr);
                    if(dic.contains(can)){
                        nextSet.add(can);
                        if(can.equals(endWord)){
                            isEnd = true;
                        }
                        
                        wToClo.putIfAbsent(cur, new HashSet<String>());
                        wToClo.get(cur).add(can);
                    }
                }
            }
        }
        
        if(!isEnd){
            bfs(nextSet, endWord, wToClo, dic);
        }
    }
    
    private void dfs(String cur, String end, HashMap<String, HashSet<String>> wToClo, List<String> item, List<List<String>> res){
        if(cur.equals(end)){
            res.add(new ArrayList<String>(item));
            return;
        }
        
        HashSet<String> nexts = wToClo.getOrDefault(cur, new HashSet<String>());
        for(String next : nexts){
            item.add(next);
            dfs(next, end, wToClo, item, res);
            item.remove(item.size() - 1);
        }
    }
}

Here since endWord could also translate, we could use bidirectional BFS to optimize.

When current set size is larger, reverse current set and end set to avoid intermidate set size is too big.

Time Complexity: O(m*n).

Space: O(m).

AC Java:

class Solution {
    public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
        List<List<String>> res = new ArrayList<>();
        Set<String> hs = new HashSet<String>(wordList);
        if(!hs.contains(endWord)){
            return res;
        }
        
        Map<String, Set<String>> map = new HashMap<>();
        Set<String> curSet = new HashSet<>();
        Set<String> endSet = new HashSet<>();
        curSet.add(beginWord);
        endSet.add(endWord);
        
        bfs(curSet, endSet, map, hs, false);
        
        List<String> item = new ArrayList<>();
        item.add(beginWord);
        dfs(beginWord, endWord, map, item, res);
        return res;
    }
    
    private void bfs(Set<String> curSet, Set<String> endSet, Map<String, Set<String>> map, Set<String> hs, boolean reverse){
        if(curSet.size() == 0){
            return;
        }
        
        if(curSet.size() > endSet.size()){
            bfs(endSet, curSet, map, hs, !reverse);
            return;
        }
        
        hs.removeAll(curSet);
        boolean findEnd = false;
        Set<String> nextSet = new HashSet<>();
        
        for(String cur : curSet){
            for(int i = 0; i<cur.length(); i++){
                char [] charArr = cur.toCharArray();
                char original = charArr[i];
                for(char k = 'a'; k<='z'; k++){
                    if(k == original){
                        continue;
                    }
                    
                    charArr[i] = k;
                    String next = new String(charArr);
                    
                    
                    if(hs.contains(next)){
                        if(endSet.contains(next)){
                            findEnd = true;
                        }else{
                            nextSet.add(next);
                        }
                        
                        String key = reverse ? next : cur;
                        String value = reverse ? cur : next;
                        map.putIfAbsent(key, new HashSet<String>());
                        map.get(key).add(value);
                    }
                }
            }
        }
        
        if(!findEnd){
            bfs(nextSet, endSet, map, hs, reverse);
        }
    }
    
    private void dfs(String curWord, String endWord, Map<String, Set<String>> map, List<String> item, List<List<String>> res){
        if(curWord.equals(endWord)){
            res.add(new ArrayList<String>(item));
            return;
        }
        
        Set<String> nextSet = map.getOrDefault(curWord, new HashSet<String>());
        for(String next : nextSet){
            item.add(next);
            dfs(next, endWord, map, item, res);
            item.remove(next);
        }
    }
}

类似Open the Lock.