feat: add solutions to lc problem: No.2491

No.2491.Divide Players Into Teams of Equal Skill

Author: yanglbme

solution/1600-1699/1689.Partitioning Into Minimum Number Of Deci-Binary Numbers/README.md

@@ -45,8 +45,12 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：脑筋急转弯**
+
 题目等价于找字符串中的最大数。
 
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为字符串长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -66,11 +70,11 @@ class Solution:
 ```java
 class Solution {
     public int minPartitions(String n) {
-        int res = 0;
-        for (char c : n.toCharArray()) {
-            res = Math.max(res, c - '0');
+        int ans = 0;
+        for (int i = 0; i < n.length(); ++i) {
+            ans = Math.max(ans, n.charAt(i) - '0');
         }
-        return res;
+        return ans;
     }
 }
 ```
@@ -81,27 +85,23 @@ class Solution {
 class Solution {
 public:
     int minPartitions(string n) {
-        int res = 0;
-        for (auto& c : n) {
-            res = max(res, c - '0');
-        }
-        return res;
+        int ans = 0;
+        for (char& c : n) ans = max(ans, c - '0');
+        return ans;
     }
 };
 ```
 
 ### **Go**
 
 ```go
-func minPartitions(n string) int {
-	res := 0
+func minPartitions(n string) (ans int) {
 	for _, c := range n {
-		t := int(c - '0')
-		if t > res {
-			res = t
+		if t := int(c - '0'); ans < t {
+			ans = t
 		}
 	}
-	return res
+	return
 }
 ```
 

solution/1600-1699/1689.Partitioning Into Minimum Number Of Deci-Binary Numbers/README_EN.md

@@ -57,11 +57,11 @@ class Solution:
 ```java
 class Solution {
     public int minPartitions(String n) {
-        int res = 0;
-        for (char c : n.toCharArray()) {
-            res = Math.max(res, c - '0');
+        int ans = 0;
+        for (int i = 0; i < n.length(); ++i) {
+            ans = Math.max(ans, n.charAt(i) - '0');
         }
-        return res;
+        return ans;
     }
 }
 ```
@@ -72,27 +72,23 @@ class Solution {
 class Solution {
 public:
     int minPartitions(string n) {
-        int res = 0;
-        for (auto& c : n) {
-            res = max(res, c - '0');
-        }
-        return res;
+        int ans = 0;
+        for (char& c : n) ans = max(ans, c - '0');
+        return ans;
     }
 };
 ```
 
 ### **Go**
 
 ```go
-func minPartitions(n string) int {
-	res := 0
+func minPartitions(n string) (ans int) {
 	for _, c := range n {
-		t := int(c - '0')
-		if t > res {
-			res = t
+		if t := int(c - '0'); ans < t {
+			ans = t
 		}
 	}
-	return res
+	return
 }
 ```
 

solution/1600-1699/1689.Partitioning Into Minimum Number Of Deci-Binary Numbers/Solution.cpp

@@ -1,10 +1,8 @@
 class Solution {
 public:
     int minPartitions(string n) {
-        int res = 0;
-        for (auto& c : n) {
-            res = max(res, c - '0');
-        }
-        return res;
+        int ans = 0;
+        for (char& c : n) ans = max(ans, c - '0');
+        return ans;
     }
 };

solution/1600-1699/1689.Partitioning Into Minimum Number Of Deci-Binary Numbers/Solution.go

@@ -1,10 +1,8 @@
-func minPartitions(n string) int {
-	res := 0
+func minPartitions(n string) (ans int) {
 	for _, c := range n {
-		t := int(c - '0')
-		if t > res {
-			res = t
+		if t := int(c - '0'); ans < t {
+			ans = t
 		}
 	}
-	return res
+	return
 }

solution/1600-1699/1689.Partitioning Into Minimum Number Of Deci-Binary Numbers/Solution.java

@@ -1,9 +1,9 @@
 class Solution {
     public int minPartitions(String n) {
-        int res = 0;
-        for (char c : n.toCharArray()) {
-            res = Math.max(res, c - '0');
+        int ans = 0;
+        for (int i = 0; i < n.length(); ++i) {
+            ans = Math.max(ans, n.charAt(i) - '0');
         }
-        return res;
+        return ans;
     }
 }

solution/2400-2499/2491.Divide Players Into Teams of Equal Skill/README.md

@@ -61,12 +61,16 @@
 
 要使得所有 $2$ 人团队的技能点相等，最小值一定需要跟最大值匹配。因此，我们将数组 `skill` 排序，然后用双指针 $i$ 和 $j$ 分别指向数组的首位，两两匹配，判断其和是否均为同一个数。
 
-若不是，说明技能点无法相等，直接返回 $-1$，否则，将化学反应累加到答案中
+若不是，说明技能点无法相等，直接返回 $-1$，否则，将化学反应累加到答案中。
 
 遍历结束，返回答案即可。
 
 时间复杂度 $O(n \times \log n)$，空间复杂度 $O(\log n)$。其中 $n$ 是数组 `skill` 的长度。
 
+**方法二：计数**
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 `skill` 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -88,6 +92,26 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def dividePlayers(self, skill: List[int]) -> int:
+        s = sum(skill)
+        m = len(skill) >> 1
+        if s % m:
+            return -1
+        t = s // m
+        d = defaultdict(int)
+        ans = 0
+        for v in skill:
+            if d[t - v]:
+                ans += v * (t - v)
+                m -= 1
+                d[t - v] -= 1
+            else:
+                d[v] += 1
+        return -1 if m else ans
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -110,6 +134,31 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public long dividePlayers(int[] skill) {
+        int s = Arrays.stream(skill).sum();
+        int m = skill.length >> 1;
+        if (s % m != 0) {
+            return -1;
+        }
+        int t = s / m;
+        int[] d = new int[1010];
+        long ans = 0;
+        for (int v : skill) {
+            if (d[t - v] > 0) {
+                ans += (long) v * (t - v);
+                --d[t - v];
+                --m;
+            } else {
+                ++d[v];
+            }
+        }
+        return m == 0 ? ans : -1;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -129,6 +178,30 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    long long dividePlayers(vector<int>& skill) {
+        int s = accumulate(skill.begin(), skill.end(), 0);
+        int m = skill.size() / 2;
+        if (s % m) return -1;
+        int t = s / m;
+        int d[1010] = {0};
+        long long ans = 0;
+        for (int& v : skill) {
+            if (d[t - v]) {
+                ans += 1ll * v * (t - v);
+                --d[t - v];
+                --m;
+            } else {
+                ++d[v];
+            }
+        }
+        return m == 0 ? ans : -1;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -146,16 +219,47 @@ func dividePlayers(skill []int) (ans int64) {
 }
 ```
 
+```go
+func dividePlayers(skill []int) int64 {
+	s := 0
+	for _, v := range skill {
+		s += v
+	}
+	m := len(skill) >> 1
+	if s%m != 0 {
+		return -1
+	}
+	t := s / m
+	d := [1010]int{}
+	ans := 0
+	for _, v := range skill {
+		if d[t-v] > 0 {
+			ans += v * (t - v)
+			d[t-v]--
+			m--
+		} else {
+			d[v]++
+		}
+	}
+	if m == 0 {
+		return int64(ans)
+	}
+	return -1
+}
+```
+
 ### **JavaScript**
 
 ```js
-var dividePlayers = function(skill) {
-    const n = skill.length, m = n / 2;
+var dividePlayers = function (skill) {
+    const n = skill.length,
+        m = n / 2;
     skill.sort((a, b) => a - b);
     const sum = skill[0] + skill[n - 1];
     let ans = 0;
     for (let i = 0; i < m; i++) {
-        const x = skill[i], y = skill[n - 1 - i];
+        const x = skill[i],
+            y = skill[n - 1 - i];
         if (x + y != sum) return -1;
         ans += x * y;
     }