0字典树/字符串中等 LeetCode676. 实现一个魔法字典

最新推荐文章于 2024-11-04 17:55:03 发布

18阿鲁

最新推荐文章于 2024-11-04 17:55:03 发布

阅读量92

点赞数

文章标签：深度优先算法

本文链接：https://blog.csdn.net/weixin_43260719/article/details/126219543

版权

这篇博客探讨了一种利用递归和前缀树（Trie）优化暴力搜索的时间复杂度的方法。文章介绍了`MagicDictionary`类的实现，通过构建字典并使用深度优先搜索（DFS）来查找目标单词，显著提高了查询效率。核心操作包括字典的构建和搜索功能，其中`buildDict`用于构建Trie结构，`search`方法则利用DFS进行搜索。

摘要由CSDN通过智能技术生成

分析

暴力的时间复杂度是
递归+前缀树
n*len(s)

class MagicDictionary {
    Trie trie;
    public MagicDictionary() {
        trie = new Trie();
    }
    
    public void buildDict(String[] dictionary) {
        for (String s : dictionary) {
            Trie cur = trie;
            for (char c : s.toCharArray()) {
                int index = c - 'a';
                if (cur.children[index] == null) {
                    cur.children[index] = new Trie();
                }
                cur = cur.children[index];
            }
            cur.end = true;
        }
    }
    
    public boolean search(String searchWord) {
        return dfs(searchWord,0,trie,1);
    }

    public boolean dfs (String word, int poi, Trie cur, int count) {
        if (count < 0 || cur == null) {
            return false;
        }
        if (poi == word.length()) {
            return count == 0 && cur.end;
        }
        int c = word.charAt(poi) - 'a';
        boolean ans = false;
        for (int i = 0; i < 26; i++) {
            if (i == c) {
                ans |= dfs(word,poi+1,cur.children[i],count);
            } else {
                ans |= dfs(word,poi+1,cur.children[i],count-1);
            }
            if (ans) {
                return true;
            }
        }
        return false;
    }
}

class Trie {
    boolean end;
    Trie[] children;
    Trie() {
        end = false;
        children = new Trie[26];
    }
}

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