Word Ladder

Given two words (start and end), and a dictionary, find all transformation sequence(s) 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

Note:

• All words have the same length.
• All words contain only lowercase alphabetic characters.

尝试用Trie 来实现这个。

最后TLE（out of time）,不过算法已经正确了。 

使用Trie，扩展性更好。 可以时时的加减dict里面的word， 也可以被多次调用。

package leetcode;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

//implement wordLadder with Trie.
/*
 * 如果这个函数要多次被调用，怎么办？
 * 因为我每次都用挨个修改字母的办法来寻找新word，但如果能先对dictionary做个预处理，弄个从word到set of words之间的mapping，那么每轮BFS就可以省去寻找新词的时间。预处理字典的复杂度也是O(size of dictionary) * (length of string) * 26。最终可以用一个Hash<String, Set<String>>来表示这个mapping关系。
 * 
 * 如果这个字典要增加/移除单词怎么办？
 * 增加的话，只需要对新单词做同样的事情：修改每个字母找下一个单词，然后那个被找到下一个单词的mapping里同时也添加进新单词。因为这个关系是可互换的，如果wordA => wordB, 那么wordB => wordA。
 * 删除的时候同理，对于map.get(toBeRemoved)里的所有单词的mapping集合都删掉这个toBeRemoved，然后再从map里面去掉它自己，写出来的代码大概是这样：
 * for (String s : map.get(toBeRemoved)) map.get(s).remove(toBeRemoved);
 * map.remove(toBeRemoved);
 * 这个地方我一开始没注意到可以互换，以为还得预处理一个反方向的mapping，经过面试官两次提醒才发现了这个规律……
 * 
 * 如果这个字典变得很庞大，这个mapping和字典本身就太占空间了，怎么处理？
 * 用trie记录所有单词，每个node用一个bit记录这个node是否为一个单词，并且有一个set<myTrieNode>的field记录他可以变成的其他单词。至于如何构建这个field，利用trie的特性，可以用回溯的方法非常简单地找到可变过去的单词（在碰到公共ancestor之前，路径上的node个数必须相同，这个用于保证长度，并且至多只有一个字母不同，用于满足mapping的条件）
 * 至此……时间终于用完了，问了下他的team的情况，就结束了……
 * 
 * */

class myTrieNode{
    Boolean isWord;
    myTrieNode[] childList;
    Integer freq;
    char val;
    String word;
    
    public myTrieNode(){//use to generate root of Trie
        this.freq = 0;
        this.childList = new myTrieNode[26];
        this.isWord = false;
    }
    
    public myTrieNode(char c){
        this.val = c;
        this.freq = 1;
        this.childList = new myTrieNode[26];
    }
    
    public String containsWord(String s){
        if(s == null || s.length() == 0){
            if(this.word != null && this.isWord == true) return this.word;
            else return "";
        }
        int len = s.length();
        myTrieNode cur = this;
        for(int i = 0; i < len; i ++){
            char c = s.charAt(i);
            if(cur.childList[c - 'a'] != null){
                cur = cur.childList[c - 'a'];
            }else{
                return null;
            }
        }
        return cur.isWord == true ? cur.word : null;
    }
}
class myTrie{
    myTrieNode root;
    
    public myTrie(){
        this.root = new myTrieNode();
    }
    
    public void insert(String word){
        if(word == null || word.length() == 0) return;
        int len = word.length();
        myTrieNode cur = this.root;
        for(int i = 0; i < len; i ++){
            char c = word.charAt(i);
            if(cur.childList[c - 'a'] == null){
                cur.childList[c - 'a'] = new myTrieNode(c);
            }else{
                cur.childList[c - 'a'].freq ++;
            }
            cur = cur.childList[c - 'a'];
            if(i == word.length() - 1){
                cur.isWord = true;
                cur.word = word;
            } 
        }
    }
    
}
public class WordLadder {
        
        
        private static myTrie trie;
        private static List<List<String>> result;
        public static List<List<String>> findLadders(String start, String end, Set<String> dict) {
            trie = generateTrie(dict);
            trie.insert(end);
            result = new ArrayList<List<String>> ();
            ArrayList<String> row = new ArrayList<String>();
            row.add(start);
            findLadderSequence(start, end, row, new HashSet<String>());
            return result;
        }
        
        private static void findLadderSequence(String start, String end, ArrayList<String> row, HashSet<String> usedSet){
            if(start.equals(end)){
                result.add(row);
            }
            myTrieNode cur = trie.root;
            myTrieNode next = cur;
            for(int i = 0; i < start.length(); i ++){
                char c = start.charAt(i);
                for(int j = 0; j < 26; j ++){
                    if(cur.childList[j] != null && cur.childList[j].val == c){
                        next = cur.childList[j];
                    }
                    if(cur.childList[j] != null && cur.childList[j].val != c){
                        String tmp = cur.childList[j].containsWord(start.substring(i + 1));
                        if(tmp != null && !usedSet.contains(tmp)){
                            row.add(tmp);
                            usedSet.add(tmp);
                            findLadderSequence(tmp, end, new ArrayList<String>(row), new HashSet<String>(usedSet));
                            row.remove(row.size() - 1);
                            usedSet.remove(tmp);
                        }
                    }
                }
                cur = next;
            }
            
        }
        
        private static myTrie generateTrie(Set<String> dict){
            myTrie trie = new myTrie();
            if(dict.isEmpty()) return trie;
            //generate Trie for dictionary
            Iterator it = dict.iterator();
            while(it.hasNext()){
                String word = (String)it.next();
                trie.insert(word);
            }
            return trie;
        }
        
    public static void main(String[] args){
        String start = "hit";
        String end = "cog";
        Set<String> dict = new HashSet<String>();
        dict.add("hot");
        dict.add("dot");
        dict.add("dog");
        dict.add("lot");
        dict.add("log");
        findLadders(start, end, dict);
        System.out.println(result);
    }
}

 Output:

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

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

[hit, hot, dot, dog, cog],

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

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

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

[hit, hot, lot, log, cog],

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