feat: add solutions to lc problem: No.0677

No.0677.Map Sum Pairs

Author: yanglbme

solution/0600-0699/0675.Cut Off Trees for Golf Event/README.md

@@ -63,7 +63,9 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-题目的一个关键信息是“所有树的高度都不同”，要按照从小到大的顺序依次砍树，因此，先遍历树林，找出所有树及对应的坐标点。然后将树按照高度升序排列。
+**方法一：BFS + 优先队列（A\* 算法）**
+
+题目的一个关键信息是“所有树的高度都不同”，要按照从小到大的顺序依次砍树，因此，我们先遍历树林，找出所有树及对应的坐标点。然后将树按照高度升序排列。
 
 接下来就是找相邻两个点之间的最短距离。可以用 BFS，A\* 算法优化搜索。
 

solution/0600-0699/0677.Map Sum Pairs/README.md

@@ -55,7 +55,20 @@ mapSum.sum("ap");           // 返回 5 (<u>ap</u>ple + <u>ap</u>p = 3 + 2 = 5)
 
 <!-- 这里可写通用的实现逻辑 -->
 
-利用哈希表存储每个键的所有前缀子串。
+**方法一：哈希表 + 前缀树**
+
+我们用哈希表 $d$ 存放键值对，用前缀树 $t$ 存放键值对的前缀和。前缀树的每个节点包含两个信息：
+
+-   `val`：以该节点为前缀的键值对的值的总和
+-   `children`：长度为 $26$ 的数组，存放该节点的子节点
+
+插入键值对 $(key, val)$ 时，我们先判断哈希表是否存在该键，如果存在，那么前缀树每个节点的 `val` 都要减去该键原来的值，然后再加上新的值。如果不存在，那么前缀树每个节点的 `val` 都要加上新的值。
+
+查询前缀和时，我们从前缀树的根节点开始，遍历前缀字符串，如果当前节点的子节点中不存在该字符，那么说明前缀树中不存在该前缀，返回 $0$。否则，继续遍历下一个字符，直到遍历完前缀字符串，返回当前节点的 `val`。
+
+时间复杂度方面，插入键值对的时间复杂度为 $O(n)$，其中 $n$ 为键的长度。查询前缀和的时间复杂度为 $O(m)$，其中 $m$ 为前缀的长度。
+
+空间复杂度 $O(n \times m \times C)$，其中 $n$ 和 $m$ 分别是键的数量以及键的最大长度；而 $C$ 是字符集的大小，本题中 $C = 26$。
 
 <!-- tabs:start -->
 
@@ -64,23 +77,43 @@ mapSum.sum("ap");           // 返回 5 (<u>ap</u>ple + <u>ap</u>p = 3 + 2 = 5)
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Trie:
+    def __init__(self):
+        self.children: List[Trie | None] = [None] * 26
+        self.val: int = 0
+
+    def insert(self, w: str, x: int):
+        node = self
+        for c in w:
+            idx = ord(c) - ord('a')
+            if node.children[idx] is None:
+                node.children[idx] = Trie()
+            node = node.children[idx]
+            node.val += x
+
+    def search(self, w: str) -> int:
+        node = self
+        for c in w:
+            idx = ord(c) - ord('a')
+            if node.children[idx] is None:
+                return 0
+            node = node.children[idx]
+        return node.val
+
+
 class MapSum:
+
     def __init__(self):
-        """
-        Initialize your data structure here.
-        """
-        self.data = defaultdict(int)
-        self.t = defaultdict(int)
+        self.d = defaultdict(int)
+        self.tree = Trie()
 
     def insert(self, key: str, val: int) -> None:
-        old = self.t[key]
-        self.t[key] = val
-        for i in range(1, len(key) + 1):
-            self.data[key[:i]] += val - old
+        x = val - self.d[key]
+        self.d[key] = val
+        self.tree.insert(key, x)
 
     def sum(self, prefix: str) -> int:
-        return self.data[prefix]
-
+        return self.tree.search(prefix)
 
 # Your MapSum object will be instantiated and called as such:
 # obj = MapSum()
@@ -93,27 +126,52 @@ class MapSum:
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Trie {
+    private Trie[] children = new Trie[26];
+    private int val;
+
+    public void insert(String w, int x) {
+        Trie node = this;
+        for (int i = 0; i < w.length(); ++i) {
+            int idx = w.charAt(i) - 'a';
+            if (node.children[idx] == null) {
+                node.children[idx] = new Trie();
+            }
+            node = node.children[idx];
+            node.val += x;
+        }
+    }
+
+    public int search(String w) {
+        Trie node = this;
+        for (int i = 0; i < w.length(); ++i) {
+            int idx = w.charAt(i) - 'a';
+            if (node.children[idx] == null) {
+                return 0;
+            }
+            node = node.children[idx];
+        }
+        return node.val;
+    }
+}
+
 class MapSum {
-    private Map<String, Integer> data;
-    private Map<String, Integer> t;
+    private Map<String, Integer> d = new HashMap<>();
+    private Trie trie = new Trie();
+
 
-    /** Initialize your data structure here. */
     public MapSum() {
-        data = new HashMap<>();
-        t = new HashMap<>();
+
     }
 
     public void insert(String key, int val) {
-        int old = t.getOrDefault(key, 0);
-        t.put(key, val);
-        for (int i = 1; i < key.length() + 1; ++i) {
-            String k = key.substring(0, i);
-            data.put(k, data.getOrDefault(k, 0) + (val - old));
-        }
+        int x = val - d.getOrDefault(key, 0);
+        d.put(key, val);
+        trie.insert(key, x);
     }
 
     public int sum(String prefix) {
-        return data.getOrDefault(prefix, 0);
+        return trie.search(prefix);
     }
 }
 
@@ -128,27 +186,59 @@ class MapSum {
 ### **C++**
 
 ```cpp
-class MapSum {
+class Trie {
 public:
-    unordered_map<string, int> data;
-    unordered_map<string, int> t;
+    Trie()
+        : children(26, nullptr) {
+    }
 
-    /** Initialize your data structure here. */
+    void insert(string& w, int x) {
+        Trie* node = this;
+        for (char c : w) {
+            c -= 'a';
+            if (!node->children[c]) {
+                node->children[c] = new Trie();
+            }
+            node = node->children[c];
+            node->val += x;
+        }
+    }
+
+    int search(string& w) {
+        Trie* node = this;
+        for (char c : w) {
+            c -= 'a';
+            if (!node->children[c]) {
+                return 0;
+            }
+            node = node->children[c];
+        }
+        return node->val;
+    }
+
+private:
+    vector<Trie*> children;
+    int val = 0;
+};
+
+class MapSum {
+public:
     MapSum() {
     }
 
     void insert(string key, int val) {
-        int old = t[key];
-        t[key] = val;
-        for (int i = 1; i < key.size() + 1; ++i) {
-            string k = key.substr(0, i);
-            data[k] += (val - old);
-        }
+        int x = val - d[key];
+        d[key] = val;
+        trie->insert(key, x);
     }
 
     int sum(string prefix) {
-        return data[prefix];
+        return trie->search(prefix);
     }
+
+private:
+    unordered_map<string, int> d;
+    Trie* trie = new Trie();
 };
 
 /**
@@ -162,30 +252,50 @@ public:
 ### **Go**
 
 ```go
+type trie struct {
+	children [26]*trie
+	val      int
+}
+
+func (t *trie) insert(w string, x int) {
+	for _, c := range w {
+		c -= 'a'
+		if t.children[c] == nil {
+			t.children[c] = &trie{}
+		}
+		t = t.children[c]
+		t.val += x
+	}
+}
+
+func (t *trie) search(w string) int {
+	for _, c := range w {
+		c -= 'a'
+		if t.children[c] == nil {
+			return 0
+		}
+		t = t.children[c]
+	}
+	return t.val
+}
+
 type MapSum struct {
-	data map[string]int
-	t    map[string]int
+	d map[string]int
+	t *trie
 }
 
-/** Initialize your data structure here. */
 func Constructor() MapSum {
-	return MapSum{
-		data: make(map[string]int),
-		t:    make(map[string]int),
-	}
+	return MapSum{make(map[string]int), &trie{}}
 }
 
 func (this *MapSum) Insert(key string, val int) {
-	old := this.t[key]
-	this.t[key] = val
-	for i := 1; i < len(key)+1; i++ {
-		k := key[:i]
-		this.data[k] += (val - old)
-	}
+	x := val - this.d[key]
+	this.d[key] = val
+	this.t.insert(key, x)
 }
 
 func (this *MapSum) Sum(prefix string) int {
-	return this.data[prefix]
+	return this.t.search(prefix)
 }
 
 /**
@@ -196,6 +306,70 @@ func (this *MapSum) Sum(prefix string) int {
  */
 ```
 
+### **TypeScript**
+
+```ts
+class Trie {
+    children: Trie[];
+    val: number;
+
+    constructor() {
+        this.children = new Array(26);
+        this.val = 0;
+    }
+
+    insert(w: string, x: number) {
+        let node: Trie = this;
+        for (const c of w) {
+            const i = c.charCodeAt(0) - 97;
+            if (!node.children[i]) {
+                node.children[i] = new Trie();
+            }
+            node = node.children[i];
+            node.val += x;
+        }
+    }
+
+    search(w: string): number {
+        let node: Trie = this;
+        for (const c of w) {
+            const i = c.charCodeAt(0) - 97;
+            if (!node.children[i]) {
+                return 0;
+            }
+            node = node.children[i];
+        }
+        return node.val;
+    }
+}
+
+class MapSum {
+    d: Map<string, number>;
+    t: Trie;
+    constructor() {
+        this.d = new Map();
+        this.t = new Trie();
+    }
+
+    insert(key: string, val: number): void {
+        const x = val - (this.d.get(key) ?? 0);
+        this.d.set(key, val);
+        this.t.insert(key, x);
+    }
+
+    sum(prefix: string): number {
+        return this.t.search(prefix);
+    }
+}
+
+/**
+ * Your MapSum object will be instantiated and called as such:
+ * var obj = new MapSum()
+ * obj.insert(key,val)
+ * var param_2 = obj.sum(prefix)
+ */
+```
+
 ### **...**
 
 ```