剑指 Offer II 064. 神奇的字典（前缀树+dfs）

---

一、题目

设计一个使用单词列表进行初始化的数据结构，单词列表中的单词 互不相同 。 如果给出一个单词，请判定能否只将这个单词中一个字母换成另一个字母，使得所形成的新单词存在于已构建的神奇字典中。

实现 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

提示：

1 <= dictionary.length <= 100
1 <= dictionary[i].length <= 100
dictionary[i] 仅由小写英文字母组成
dictionary 中的所有字符串 互不相同
1 <= searchWord.length <= 100
searchWord 仅由小写英文字母组成
buildDict 仅在 search 之前调用一次
最多调用 100 次 search

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/US1pGT

二、前缀树+dfs

解题思路：

1. 建立前缀树，26个字母，想象成26叉树
2. 数中定义boolean变量isEnd，以判断是否长度一致，避免出现hello与hell匹配成功等情况
3. dfs()方法中，用变量flag标记是否替换，如flag为false，则每轮中都可选择替换或不替换dfs，如flag为true，后序只能进行不替换dfs。
4. 如当前字符在子树中为null，则只能替换
5. 如替换与不替换都为false，则返回false

class MagicDictionary {
    class TreeNode{
        TreeNode[] kids;
        boolean isEnd;
        public TreeNode(){
            kids=new TreeNode[26];
            isEnd=false;
        }
    }
    
    public void insert(String dictionary){
        TreeNode node = root;
        for(int i=0;i<dictionary.length();i++){
            int index = dictionary.charAt(i)-'a';
            if(node.kids[index]==null) node.kids[index]=new TreeNode();
            node = node.kids[index];
        }
        node.isEnd=true;
    }
    TreeNode root = new TreeNode();
    /** Initialize your data structure here. */
    public MagicDictionary() {

    }
    
    public void buildDict(String[] dictionary) {
        for(String s:dictionary)
            insert(s);
    }
    
    public boolean search(String searchWord) {
        return dfs(searchWord,0,false,root);
    }
    //flag标记是否替换
    public boolean dfs(String word,int i,boolean flag,TreeNode root){
        if(i==word.length()) return flag&&root.isEnd;
        int index = word.charAt(i++)-'a';
        TreeNode node = root.kids[index];

        //不替换直接dfs
        if(node!=null&&dfs(word,i,flag,node)) return true;
        //flag为false，就是还有替换机会，直接遍历替换
        if(!flag){
            for(TreeNode tn:root.kids){
                if(tn!=null&&tn!=node&&dfs(word,i,true,tn)) return true;
                
            }
            // for(char c='a';c<='z';c++){
            //     TreeNode tn = root.kids[c-'a'];
            //     if(tn!=null&&tn!=node&&dfs(word,i,true,tn)) return true;
            // }
        }
        
        //前面不替换和替换后都失败，就直接返回false
        return false;
    }
    // //flag标记是否替换
    // public boolean dfs(String word,int i,boolean flag,TreeNode root){
    //     if(i==word.length()) return flag&&root.isEnd;
    //     int index = word.charAt(i++)-'a';
    //     TreeNode node = root.kids[index];
    //     if(flag){
    //         if(node==null) return false;
    //         return dfs(word,i,flag,node);
    //     }else{
    //         for(TreeNode tn:root.kids){
    //             //不为null且不等于node
    //             if(tn!=null&&tn!=node){
    //                 if(dfs(word,i,true,tn)) 
    //                     return true;
    //             }
    //         }
    //     }
    //     //在上面替换第一个字符后，查找不到
    //     //又因为当前第一个字符没在字典中，所以直接false
    //     if (node == null) {
    //         return false;
    //     }
    //     //当前字符不替换
    //     return dfs(word, i, false, node);
    // }
}

/**
 * Your MagicDictionary object will be instantiated and called as such:
 * MagicDictionary obj = new MagicDictionary();
 * obj.buildDict(dictionary);
 * boolean param_2 = obj.search(searchWord);
 */

---