剑指offer64：神奇的字典

题目：
设计一个使用单词列表进行初始化的数据结构，单词列表中的单词互不相同 。 如果给出一个单词，请判定能否只将这个单词中一个字母换成另一个字母，使得所形成的新单词存在于已构建的神奇字典中。
实现 MagicDictionary 类：
MagicDictionary() 初始化对象
void buildDict(String[] dictionary) 使用字符串数组 dictionary 设定该数据结构，dictionary 中的字符串互不相同
bool search(String searchWord) 给定一个字符串 searchWord ，判定能否只将字符串中一个字母换成另一个字母，使得所形成的新字符串能够与字典中的任一字符串匹配。如果可以，返回 true ；否则，返回 false 。

//输入
inputs = ["MagicDictionary", "buildDict", "search", "search", "search", "search"]
inputs = [[], [["hello", "leetcode"]], ["hello"], ["hhllo"], ["hell"], ["leetcoded"]]
输出
[null, null, false, true, false, false]

//解释
MagicDictionary magicDictionary = new MagicDictionary();
magicDictionary.buildDict(["hello", "leetcode"]);
magicDictionary.search("hello"); // 返回 False
magicDictionary.search("hhllo"); // 将第二个 'h' 替换为 'e' 可以匹配 "hello" ，所以返回 True
magicDictionary.search("hell"); // 返回 False
magicDictionary.search("leetcoded"); // 返回 False

分析：
将每个单词保存到哈希表中并不能解决这个问题，这是因为字符串的哈希值和原来字符串的哈希值没有任何关系，因此若是要用哈希表保存的字典中所有的单词，就没办法找出只修改一个字符的字符串。我们可以考虑前缀树，将字典中的字符串前部放入前缀树中，然后通过前缀树查找只修改一个字符的字符串，可以通过深度优先的顺序搜索前缀树的每条路径，如果到达的节点与字符串中的字符不匹配，则表示此时修改了字符串中的一个字符来匹配前缀树中的路径，如果到达的最后一个字符对应的节点，该节点isWord为true，并且此时刚好只修改了字符串中一个字符对应的路径，可以返回true。具体见代码，看注释。
代码：

public class MagicDictionary {
    public static void main(String[] args) {
        String[] dictionary = {"happy","new","year"};
        String searchWord = "now";
        MagicDictionary magicDictionary = new MagicDictionary();
        magicDictionary.buildDict(dictionary);
        boolean search = magicDictionary.search(searchWord);
        System.out.println(search);
    }
    static class TrieNode{
        public TrieNode[] children;
        public boolean isWord;
        public TrieNode(){
            children = new TrieNode[26];

        }
    }
    TrieNode root;
    /** Initialize your data structure here. */
    public MagicDictionary() {
         root = new TrieNode();
    }
//通过字典建立一个前缀树
    public  void buildDict(String[] dictionary) {
        for (String word:dictionary){
            TrieNode node = root;
            for (char ch:word.toCharArray()){
                if (node.children[ch-'a'] == null){
                    node.children[ch-'a'] = new TrieNode();
                }
                node = node.children[ch-'a'];
            }
            node.isWord = true;
        }
    }

    public  boolean search(String searchWord) {
//        根据深度优先的顺序搜索前缀树的每条路径
        return dfs(root,searchWord,0,0);
    }
//第三个参数i是当前查找的字符串中字符的下标，第四个参数edit是在字符串中当前已经修改的字符的个数
    private  boolean dfs(TrieNode root, String searchWord, int i, int edit) {
    //有孩子节点深入到下一层
        if (root == null){
            return false;
        }
        if (root.isWord && i==searchWord.length() && edit==1){
            return true;
        }
        if (i < searchWord.length() && edit <=1){
            boolean found = false;
            //！found的作用就是当返回true时不需要再接着遍历，一直返回到根节点
            for (int j=0;j<26 && !found; j++){
//从头开始遍历26个字母搜索孩子节点，遍历到第一个孩子节点h时，与目标字符串now的一个字符n比较，不同则edit加1，代表修改一个字符，相同则edit不变
//如果第一个孩子节点有孩子节点进入下一层，遍历到下一层的第一个孩子节点a与目标字符串now的第二个字符o比较，比较规则和之前的一样，edit再加1
//edit>1了，直接返回false，返回上一层，寻找上一层第二个孩子节点也就是n......
                int next = j==searchWord.charAt(i) - 'a' ?edit:edit+1;
                found = dfs(root.children[j],searchWord,i+1,next);
            }
            return found;
        }
        //全遍历完，都没有找到，返回false
        return false;
    }
}