feat: leetcode 676

Author: deweyou

README.md

@@ -2,7 +2,7 @@
 
 <p align="center">
 <!-- TOPICS COUNT START -->
-<img src="https://img.shields.io/badge/-进度:427-green" alt="进度:427">
+<img src="https://img.shields.io/badge/-进度:428-green" alt="进度:428">
 <!-- TOPICS COUNT END -->
 <a href="./assets/docs/TOPICS.md"><img src="https://img.shields.io/badge/-题库目录-blue" alt="题库目录"></a>
 <a href="./assets/docs/CATEGORIES.md"><img src="https://img.shields.io/badge/-题库分类-red" alt="题库分类"></a>

assets/data/categories.json

@@ -3428,6 +3428,12 @@
         "path": "./problemset/longest-uncommon-subsequence-2/README.md",
         "difficulty": "中等"
       },
+      {
+        "id": "676",
+        "title": "实现一个魔法字典",
+        "path": "./problemset/implement-magic-dictionary/README.md",
+        "difficulty": "中等"
+      },
       {
         "id": "699",
         "title": "掉落的方块",
@@ -3616,6 +3622,12 @@
         "title": "字典序的第K小数字",
         "path": "./problemset/k-th-smallest-in-lexicographical-order/README.md",
         "difficulty": "困难"
+      },
+      {
+        "id": "676",
+        "title": "实现一个魔法字典",
+        "path": "./problemset/implement-magic-dictionary/README.md",
+        "difficulty": "中等"
       }
     ]
   },

assets/data/topics.json

@@ -3239,6 +3239,16 @@
     "url": "https://leetcode.cn/problems/cut-off-trees-for-golf-event/",
     "path": "./problemset/cut-off-trees-for-golf-event/README.md"
   },
+  {
+    "id": "676",
+    "title": {
+      "cn": "实现一个魔法字典",
+      "en": "implement-magic-dictionary"
+    },
+    "difficulty": "中等",
+    "url": "https://leetcode.cn/problems/implement-magic-dictionary/",
+    "path": "./problemset/implement-magic-dictionary/README.md"
+  },
   {
     "id": "682",
     "title": {

assets/docs/CATEGORIES.md

@@ -650,6 +650,7 @@
 | 204. [计数质数](../../problemset/count-primes/README.md) | 中等 |
 | 479. [最大回文数乘积](../../problemset/largest-palindrome-product/README.md) | 困难 |
 | 522. [最长特殊序列 II](../../problemset/longest-uncommon-subsequence-2/README.md) | 中等 |
+| 676. [实现一个魔法字典](../../problemset/implement-magic-dictionary/README.md) | 中等 |
 | 699. [掉落的方块](../../problemset/falling-squares/README.md) | 困难 |
 | 812. [最大三角形面积](../../problemset/largest-triangle-area/README.md) | 简单 |
 | 1601. [最多可达成的换楼请求数目](../../problemset/maximum-number-of-achievable-transfer-requests/README.md) | 困难 |
@@ -694,6 +695,7 @@
 | 211. [添加与搜索单词 - 数据结构设计](../../problemset/design-add-and-search-words-data-structure/README.md) | 中等 |
 | 212. [单词搜索 II](../../problemset/word-search-2/README.md) | 困难 |
 | 440. [字典序的第K小数字](../../problemset/k-th-smallest-in-lexicographical-order/README.md) | 困难 |
+| 676. [实现一个魔法字典](../../problemset/implement-magic-dictionary/README.md) | 中等 |
 
 ## 优先队列
 

assets/docs/TOPICS.md

@@ -648,6 +648,8 @@
 
 [675. 为高尔夫比赛砍树](../../problemset/cut-off-trees-for-golf-event/README.md)
 
+[676. 实现一个魔法字典](../../problemset/implement-magic-dictionary/README.md)
+
 [682. 棒球比赛](../../problemset/baseball-game/README.md)
 
 [688. 骑士在棋盘上的概率](../../problemset/knight-probability-in-chessboard/README.md)

problemset/implement-magic-dictionary/README.md

@@ -0,0 +1,122 @@
+# 实现一个魔法字典
+
+> 难度：中等
+>
+> https://leetcode.cn/problems/implement-magic-dictionary/
+
+## 题目
+
+设计一个使用单词列表进行初始化的数据结构，单词列表中的单词 **互不相同** 。 如果给出一个单词，请判定能否只将这个单词中一个字母换成另一个字母，使得所形成的新单词存在于你构建的字典中。
+
+实现 `MagicDictionary` 类：
+
+- `MagicDictionary()` 初始化对象
+- `void buildDict(String[] dictionary)` `使用字符串数组 dictionary` `设定该数据结构，dictionary` 中的字符串互不相同
+- `bool search(String searchWord)` 给定一个字符串 `searchWord` ，判定能否只将字符串中 **一个** 字母换成另一个字母，使得所形成的新字符串能够与字典中的任一字符串匹配。如果可以，返回 `true` ；否则，返回 `false` 。
+ 
+
+### 示例：
+
+```
+输入
+["MagicDictionary", "buildDict", "search", "search", "search", "search"]
+[[], [["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
+```
+
+## 解题
+
+### 枚举每个字典中的字符串并判断
+
+```ts
+/**
+ * 枚举每个字典中的字符串并判断
+ * @desc 时间复杂度 O(qnl)  空间复杂度 O(nl)
+ * @desc 其中n是dictionary 的长度，l是dictionary中字符串的平均长度，q是函数search(searchWord)的调用次数
+ */
+export class MagicDictionary {
+  words: string[] = []
+
+  buildDict(dictionary: string[]): void {
+    this.words = dictionary
+  }
+
+  search(searchWord: string): boolean {
+    for (const word of this.words) {
+      if (word.length !== searchWord.length) continue
+      let diff = 0
+
+      for (let i = 0; i < word.length; i++) {
+        if (word[i] !== searchWord[i]) {
+          diff++
+          if (diff > 1) break
+        }
+      }
+      if (diff === 1) return true
+    }
+    return false
+  }
+}
+```
+
+### 使用字典树优化枚举
+
+```ts
+/**
+ * 使用字典树优化枚举
+ * @desc 时间复杂度 O(nl+ql∣Σ∣)  空间复杂度 O(nl)
+ * @desc 其中n是dictionary 的长度，l是dictionary中字符串的平均长度，q是函数search(searchWord)的调用次数，Σ 是字符集
+ */
+export class MagicDictionary2 {
+  root = new Trie()
+
+  buildDict(dictionary: string[]): void {
+    for (const word of dictionary) {
+      let cur: Trie = this.root
+      for (let i = 0; i < word.length; i++) {
+        const ch = word[i]
+        const idx = ch.charCodeAt(0) - 'a'.charCodeAt(0)
+        if (!cur.child[idx]) cur!.child[idx] = new Trie()
+        cur = cur.child[idx] as Trie
+      }
+      cur.isFinished = true
+    }
+  }
+
+  search(searchWord: string): boolean {
+    return this._dfs(searchWord)
+  }
+
+  private _dfs(searchWord: string, node: Trie = this.root, pos = 0, modified = false): boolean {
+    if (pos === searchWord.length) return modified && node.isFinished
+
+    const idx = searchWord[pos].charCodeAt(0) - 'a'.charCodeAt(0)
+    if (node.child[idx] && this._dfs(searchWord, node.child[idx]!, pos + 1, modified)) return true
+
+    if (!modified) {
+      for (let i = 0; i < 26; i++) {
+        if (i !== idx && node.child[i]) {
+          if (this._dfs(searchWord, node.child[i]!, pos + 1, true))
+            return true
+        }
+      }
+    }
+
+    return false
+  }
+}
+
+class Trie {
+  isFinished = false
+  child: (Trie | null)[] = new Array(26).fill(null)
+}
+```

problemset/implement-magic-dictionary/index.spec.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+import { MagicDictionary, MagicDictionary2 } from '.'
+
+describe('实现一个魔法字典', () => {
+  describe('枚举每个字典中的字符串并判断', () => testCase(MagicDictionary))
+  describe('使用字典树优化枚举', () => testCase(MagicDictionary2))
+})
+
+type CtorType = new () => ({
+  buildDict: (dictionary: string[]) => void
+  search: (searchWord: string) => boolean
+})
+
+function testCase(Ctor: CtorType) {
+  it('示例', () => {
+    const magicDictionary = new Ctor()
+    magicDictionary.buildDict(['hello', 'leetcode'])
+    expect(magicDictionary.search('hello')).toBe(false) // 返回 False
+    expect(magicDictionary.search('hhllo')).toBe(true) // 将第二个 'h' 替换为 'e' 可以匹配 "hello" ，所以返回 True
+    expect(magicDictionary.search('hell')).toBe(false) // 返回 False
+    expect(magicDictionary.search('leetcoded')).toBe(false) // 返回 False
+  })
+}

problemset/implement-magic-dictionary/index.ts

@@ -0,0 +1,77 @@
+/**
+ * 枚举每个字典中的字符串并判断
+ * @desc 时间复杂度 O(qnl)  空间复杂度 O(nl)
+ * @desc 其中n是dictionary 的长度，l是dictionary中字符串的平均长度，q是函数search(searchWord)的调用次数
+ */
+export class MagicDictionary {
+  words: string[] = []
+
+  buildDict(dictionary: string[]): void {
+    this.words = dictionary
+  }
+
+  search(searchWord: string): boolean {
+    for (const word of this.words) {
+      if (word.length !== searchWord.length) continue
+      let diff = 0
+
+      for (let i = 0; i < word.length; i++) {
+        if (word[i] !== searchWord[i]) {
+          diff++
+          if (diff > 1) break
+        }
+      }
+      if (diff === 1) return true
+    }
+    return false
+  }
+}
+
+/**
+ * 使用字典树优化枚举
+ * @desc 时间复杂度 O(nl+ql∣Σ∣)  空间复杂度 O(nl)
+ * @desc 其中n是dictionary 的长度，l是dictionary中字符串的平均长度，q是函数search(searchWord)的调用次数，Σ 是字符集
+ */
+export class MagicDictionary2 {
+  root = new Trie()
+
+  buildDict(dictionary: string[]): void {
+    for (const word of dictionary) {
+      let cur: Trie = this.root
+      for (let i = 0; i < word.length; i++) {
+        const ch = word[i]
+        const idx = ch.charCodeAt(0) - 'a'.charCodeAt(0)
+        if (!cur.child[idx]) cur!.child[idx] = new Trie()
+        cur = cur.child[idx] as Trie
+      }
+      cur.isFinished = true
+    }
+  }
+
+  search(searchWord: string): boolean {
+    return this._dfs(searchWord)
+  }
+
+  private _dfs(searchWord: string, node: Trie = this.root, pos = 0, modified = false): boolean {
+    if (pos === searchWord.length) return modified && node.isFinished
+
+    const idx = searchWord[pos].charCodeAt(0) - 'a'.charCodeAt(0)
+    if (node.child[idx] && this._dfs(searchWord, node.child[idx]!, pos + 1, modified)) return true
+
+    if (!modified) {
+      for (let i = 0; i < 26; i++) {
+        if (i !== idx && node.child[i]) {
+          if (this._dfs(searchWord, node.child[i]!, pos + 1, true))
+            return true
+        }
+      }
+    }
+
+    return false
+  }
+}
+
+class Trie {
+  isFinished = false
+  child: (Trie | null)[] = new Array(26).fill(null)
+}