feat: add solutions to lc problem: No.1086

No.1086.High Five

Author: yanglbme

solution/1000-1099/1080.Insufficient Nodes in Root to Leaf Paths/README.md

@@ -53,9 +53,17 @@
 
 **方法一：递归**
 
-递归遍历整棵树，如果到达叶子结点且路径和小于 $limit$，直接返回 `null` 表示删除。如果左右子树都被删除，说明经过当前结点的路径和也一定小于 $limit$，同样需要删除。
+我们递归遍历整棵树，对于当前遍历到的节点 $root$：
 
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉树的结点数。
+如果 $root$ 为空，那么返回空；否则，我们将 $limit$ 减去当前节点的值，即 $limit = limit - root.val$，然后继续执行下述步骤。
+
+如果 $root$ 为叶子节点（即 $root$ 的左右子节点都为空），说明我们已经走完了一条从根节点到叶子节点的路径。如果此时 $limit \gt 0$，说明该路径上所有节点的值的和小于 $limit$，我们返回空节点，表示删除；否则，说明该路径上所有节点的值的和大于等于 $limit$，我们返回 $root$。
+
+如果 $root$ 不是叶子节点，那么我们递归调用函数 $sufficientSubset$，对 $root$ 的左右子节点分别进行处理，并将返回值分别赋值给 $root$ 的左右子节点。
+
+如果 $root$ 的左右子节点在经过递归调用后变成了空节点，那么说明 $root$ 的左右子树中所有从根节点到叶子节点的路径上所有节点的值的和都小于 $limit$，因此我们返回空节点，表示删除 $root$；否则，说明 $root$ 的左右子树中存在从根节点到叶子节点上所有节点值的和大于等于 $limit$ 的路径，因此我们返回 $root$。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉树的节点个数。
 
 <!-- tabs:start -->
 

solution/1000-1099/1086.High Five/README.md

@@ -47,7 +47,11 @@ ID = 2 的学生分数为 93、97、77、100 和 76 。前五科的平均分 (10
 
 <!-- 这里可写通用的实现逻辑 -->
 
-“桶排序 + 小根堆”实现。
+**方法一：排序**
+
+我们先用一个哈希表或数组 $d$ 记录每个学生的分数列表，然后从小到大遍历学生的编号，对于每个学生，我们将他的分数列表排序，然后取最高的五个分数求平均值即可。
+
+时间复杂度 $O(n \log n)$，空间复杂度 $O(n)$。其中 $n$ 是学生的数量。
 
 <!-- tabs:start -->
 
@@ -58,18 +62,17 @@ ID = 2 的学生分数为 93、97、77、100 和 76 。前五科的平均分 (10
 ```python
 class Solution:
     def highFive(self, items: List[List[int]]) -> List[List[int]]:
-        s = [None] * 101
-        for i, score in items:
-            if s[i] is None:
-                s[i] = []
-            s[i].append(score)
-        res = []
-        for i, scores in enumerate(s):
-            if scores is None:
-                continue
-            avg = sum(nlargest(5, scores)) // 5
-            res.append([i, avg])
-        return res
+        d = defaultdict(list)
+        m = 0
+        for i, x in items:
+            d[i].append(x)
+            m = max(m, i)
+        ans = []
+        for i in range(1, m + 1):
+            if xs := d[i]:
+                avg = sum(nlargest(5, xs)) // 5
+                ans.append([i, avg])
+        return ans
 ```
 
 ### **Java**
@@ -116,6 +119,78 @@ class Solution {
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<vector<int>> highFive(vector<vector<int>>& items) {
+        vector<int> d[1001];
+        for (auto& item : items) {
+            int i = item[0], x = item[1];
+            d[i].push_back(x);
+        }
+        vector<vector<int>> ans;
+        for (int i = 1; i <= 1000; ++i) {
+            if (!d[i].empty()) {
+                sort(d[i].begin(), d[i].end(), greater<int>());
+                int s = 0;
+                for (int j = 0; j < 5; ++j) {
+                    s += d[i][j];
+                }
+                ans.push_back({i, s / 5});
+            }
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func highFive(items [][]int) (ans [][]int) {
+	d := make([][]int, 1001)
+	for _, item := range items {
+		i, x := item[0], item[1]
+		d[i] = append(d[i], x)
+	}
+	for i := 1; i <= 1000; i++ {
+		if len(d[i]) > 0 {
+			sort.Ints(d[i])
+			s := 0
+			for j := len(d[i]) - 1; j >= len(d[i])-5; j-- {
+				s += d[i][j]
+			}
+			ans = append(ans, []int{i, s / 5})
+		}
+	}
+	return ans
+}
+```
+
+### **TypeScript**
+
+```ts
+function highFive(items: number[][]): number[][] {
+    const d: number[][] = Array(1001)
+        .fill(0)
+        .map(() => Array(0));
+    for (const [i, x] of items) {
+        d[i].push(x);
+    }
+    const ans: number[][] = [];
+    for (let i = 1; i <= 1000; ++i) {
+        if (d[i].length > 0) {
+            d[i].sort((a, b) => b - a);
+            const s = d[i].slice(0, 5).reduce((a, b) => a + b);
+            ans.push([i, Math.floor(s / 5)]);
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/1000-1099/1086.High Five/README_EN.md

@@ -48,59 +48,118 @@ The student with ID = 2 got scores 93, 97, 77, 100, and 76. Their top five avera
 ```python
 class Solution:
     def highFive(self, items: List[List[int]]) -> List[List[int]]:
-        s = [None] * 101
-        for i, score in items:
-            if s[i] is None:
-                s[i] = []
-            s[i].append(score)
-        res = []
-        for i, scores in enumerate(s):
-            if scores is None:
-                continue
-            avg = sum(nlargest(5, scores)) // 5
-            res.append([i, avg])
-        return res
+        d = defaultdict(list)
+        m = 0
+        for i, x in items:
+            d[i].append(x)
+            m = max(m, i)
+        ans = []
+        for i in range(1, m + 1):
+            if xs := d[i]:
+                avg = sum(nlargest(5, xs)) // 5
+                ans.append([i, avg])
+        return ans
 ```
 
 ### **Java**
 
 ```java
 class Solution {
     public int[][] highFive(int[][] items) {
-        int size = 0;
-        PriorityQueue[] s = new PriorityQueue[101];
-        int n = 5;
-        for (int[] item : items) {
-            int i = item[0], score = item[1];
-            if (s[i] == null) {
-                ++size;
-                s[i] = new PriorityQueue<>(n);
-            }
-            s[i].offer(score);
-            if (s[i].size() > n) {
-                s[i].poll();
+        List<Integer>[] d = new List[1001];
+        Arrays.setAll(d, k -> new ArrayList<>());
+        for (var item : items) {
+            int i = item[0], x = item[1];
+            d[i].add(x);
+        }
+        for (var xs : d) {
+            xs.sort((a, b) -> b - a);
+        }
+        List<int[]> ans = new ArrayList<>();
+        for (int i = 1; i <= 1000; ++i) {
+            var xs = d[i];
+            if (!xs.isEmpty()) {
+                int s = 0;
+                for (int j = 0; j < 5; ++j) {
+                    s += xs.get(j);
+                }
+                ans.add(new int[]{i, s / 5});
             }
         }
-        int[][] res = new int[size][2];
-        int j = 0;
-        for (int i = 0; i < 101; ++i) {
-            if (s[i] == null) {
-                continue;
+        return ans.toArray(new int[0][]);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<vector<int>> highFive(vector<vector<int>>& items) {
+        vector<int> d[1001];
+        for (auto& item : items) {
+            int i = item[0], x = item[1];
+            d[i].push_back(x);
+        }
+        vector<vector<int>> ans;
+        for (int i = 1; i <= 1000; ++i) {
+            if (!d[i].empty()) {
+                sort(d[i].begin(), d[i].end(), greater<int>());
+                int s = 0;
+                for (int j = 0; j < 5; ++j) {
+                    s += d[i][j];
+                }
+                ans.push_back({i, s / 5});
             }
-            int avg = sum(s[i]) / n;
-            res[j][0] = i;
-            res[j++][1] = avg;
         }
-        return res;
+        return ans;
     }
+};
+```
+
+### **Go**
+
+```go
+func highFive(items [][]int) (ans [][]int) {
+	d := make([][]int, 1001)
+	for _, item := range items {
+		i, x := item[0], item[1]
+		d[i] = append(d[i], x)
+	}
+	for i := 1; i <= 1000; i++ {
+		if len(d[i]) > 0 {
+			sort.Ints(d[i])
+			s := 0
+			for j := len(d[i]) - 1; j >= len(d[i])-5; j-- {
+				s += d[i][j]
+			}
+			ans = append(ans, []int{i, s / 5})
+		}
+	}
+	return ans
+}
+```
 
-    private int sum(PriorityQueue<Integer> q) {
-        int s = 0;
-        while (!q.isEmpty()) {
-            s += q.poll();
+### **TypeScript**
+
+```ts
+function highFive(items: number[][]): number[][] {
+    const d: number[][] = Array(1001)
+        .fill(0)
+        .map(() => Array(0));
+    for (const [i, x] of items) {
+        d[i].push(x);
+    }
+    const ans: number[][] = [];
+    for (let i = 1; i <= 1000; ++i) {
+        if (d[i].length > 0) {
+            d[i].sort((a, b) => b - a);
+            const s = d[i].slice(0, 5).reduce((a, b) => a + b);
+            ans.push([i, Math.floor(s / 5)]);
         }
-        return s;
     }
+    return ans;
 }
 ```
 

solution/1000-1099/1086.High Five/Solution.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    vector<vector<int>> highFive(vector<vector<int>>& items) {
+        vector<int> d[1001];
+        for (auto& item : items) {
+            int i = item[0], x = item[1];
+            d[i].push_back(x);
+        }
+        vector<vector<int>> ans;
+        for (int i = 1; i <= 1000; ++i) {
+            if (!d[i].empty()) {
+                sort(d[i].begin(), d[i].end(), greater<int>());
+                int s = 0;
+                for (int j = 0; j < 5; ++j) {
+                    s += d[i][j];
+                }
+                ans.push_back({i, s / 5});
+            }
+        }
+        return ans;
+    }
+};

solution/1000-1099/1086.High Five/Solution.go

@@ -0,0 +1,18 @@
+func highFive(items [][]int) (ans [][]int) {
+	d := make([][]int, 1001)
+	for _, item := range items {
+		i, x := item[0], item[1]
+		d[i] = append(d[i], x)
+	}
+	for i := 1; i <= 1000; i++ {
+		if len(d[i]) > 0 {
+			sort.Ints(d[i])
+			s := 0
+			for j := len(d[i]) - 1; j >= len(d[i])-5; j-- {
+				s += d[i][j]
+			}
+			ans = append(ans, []int{i, s / 5})
+		}
+	}
+	return ans
+}

solution/1000-1099/1086.High Five/Solution.java

@@ -1,37 +1,25 @@
 class Solution {
     public int[][] highFive(int[][] items) {
-        int size = 0;
-        PriorityQueue[] s = new PriorityQueue[101];
-        int n = 5;
-        for (int[] item : items) {
-            int i = item[0], score = item[1];
-            if (s[i] == null) {
-                ++size;
-                s[i] = new PriorityQueue<>(n);
-            }
-            s[i].offer(score);
-            if (s[i].size() > n) {
-                s[i].poll();
-            }
+        List<Integer>[] d = new List[1001];
+        Arrays.setAll(d, k -> new ArrayList<>());
+        for (var item : items) {
+            int i = item[0], x = item[1];
+            d[i].add(x);
         }
-        int[][] res = new int[size][2];
-        int j = 0;
-        for (int i = 0; i < 101; ++i) {
-            if (s[i] == null) {
-                continue;
-            }
-            int avg = sum(s[i]) / n;
-            res[j][0] = i;
-            res[j++][1] = avg;
+        for (var xs : d) {
+            xs.sort((a, b) -> b - a);
         }
-        return res;
-    }
-
-    private int sum(PriorityQueue<Integer> q) {
-        int s = 0;
-        while (!q.isEmpty()) {
-            s += q.poll();
+        List<int[]> ans = new ArrayList<>();
+        for (int i = 1; i <= 1000; ++i) {
+            var xs = d[i];
+            if (!xs.isEmpty()) {
+                int s = 0;
+                for (int j = 0; j < 5; ++j) {
+                    s += xs.get(j);
+                }
+                ans.add(new int[]{i, s / 5});
+            }
         }
-        return s;
+        return ans.toArray(new int[0][]);
     }
 }