Leetcode 676. Implement Magic Dictionary

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;
};

beat 99%的大佬是循环遍历，剪枝很强，代码非常干净，没有任何多余的code