Leetcode 676. Implement Magic Dictionary

最新推荐文章于 2024-08-12 08:50:16 发布

Relati

最新推荐文章于 2024-08-12 08:50:16 发布

阅读量767

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode指北

本文链接：https://blog.youkuaiyun.com/Relati/article/details/78286710

leetcode指北专栏收录该内容

8 篇文章

订阅专栏

本文介绍LeetCode上一道关于实现魔法字典的问题，并提供两种解决方案：一种使用HashMap优化搜索效率；另一种采用循环遍历的方式。同时分享了如何通过减少不必要的遍历来提升算法性能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

https://leetcode.com/problems/implement-magic-dictionary/description/
https://discuss.leetcode.com/topic/102992/easy-14-lines-java-solution-hashmap
优化思路来自discuss的@shawngao，表示感谢！

Implement a magic directory with buildDict, and search methods.

For the method buildDict, you’ll be given a list of non-repetitive words to build a dictionary.

For the method search, you’ll be given a word, and judge whether if you modify exactly one character into another character in this word, the modified word is in the dictionary you just built.

Example 1:
Input: buildDict([“hello”, “leetcode”]), Output: Null
Input: search(“hello”), Output: False
Input: search(“hhllo”), Output: True
Input: search(“hell”), Output: False
Input: search(“leetcoded”), Output: False
Note:
You may assume that all the inputs are consist of lowercase letters a-z.
For contest purpose, the test data is rather small by now. You could think about highly efficient algorithm after the contest.
Please remember to RESET your class variables declared in class MagicDictionary, as static/class variables are persisted across multiple test cases. Please see here for more details.

循环遍历统计差异就可以AC了，但是仔细分析一下，假设有dict有n个word，要查询的word长度是m，那么遍历统计最坏需要O(nm)，这样做的话只能beat 40%左右。
我们可以利用hashmap来提速。
针对modify exactly one character into another character in this word，所以我们可以将word去掉word[i]作为key，然后记录此时索引和字符值的{index: i, char: word[i]}，通过对比同一个index位置不同的char字符值，就能准确知道当前的word是否在dict中。
例如hello建立hashmap后

dictHashMap: {
  ello: [ { index: 0, char: 'h' } ],
  hllo: [ { index: 1, char: 'e' } ],
  helo: [ { index: 2, char: 'l' }, { index: 3, char: 'l' } ],
  hell: [ { index: 4, char: 'o' } ],
}

利用hashmap，大概能beat 70%了

var MagicDictionary = function() {
    this.dictHashMap = {};
};

MagicDictionary.prototype.buildDict = function(dict) {
    this.dictHashMap = {};
    for (let i = 0; i < dict.length; ++i) {
        const word = dict[i]
        for (let j = 0; j < word.length; ++j) {
            const value = { index: j, char: word[j] };
            const key = word.slice(0, j) + word.slice(j+1);
            if (!this.dictHashMap[key]) {
                this.dictHashMap[key] = [];
            }
            this.dictHashMap[key].push(value);
        }
    }
};

MagicDictionary.prototype.search = function(word) {
    for (let i = 0; i < word.length; ++i) {
        const key = word.slice(0, i) + word.slice(i+1);
        if (this.dictHashMap[key] &&
            this.dictHashMap[key].map(({index, char}) => {
                return index == i && char != word[i];
            }).reduce((pre, next)=>{
                return pre || next;
            }, false)

        ) {
            return true;
        }
    }
    return false;
};

不用hashmap如下

var MagicDictionary = function() {
    this.dict = [];
};
MagicDictionary.prototype.buildDict = function(dict) {
    this.dict = dict;
};
MagicDictionary.prototype.diff = (dictWord, word) => {
    let diffCount = 0;
    if (dictWord.length == word.length) {
        for (let i = 0; i < dictWord.length; ++i) {
            diffCount += dictWord[i] == word[i] ? 0 : 1;
        }
    }
    return diffCount == 1 ? true : false;
}
MagicDictionary.prototype.search = function(word) {
    for (let i = 0; i < this.dict.length; ++i) {
        if (this.diff(this.dict[i], word)) {
            return true;
        }
    }
    return false;
};