feat: add solutions to lc problem: No.1887

yanglbme · yanglbme · commit e2f785e8b2cd · 2022-08-08T14:54:28.000+08:00
No.1887.Reduction Operations to Make the Array Elements Equal
diff --git a/solution/1800-1899/1887.Reduction Operations to Make the Array Elements Equal/README.md b/solution/1800-1899/1887.Reduction Operations to Make the Array Elements Equal/README.md
@@ -62,7 +62,13 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-排序。
+**方法一：排序**
+
+对 $nums$ 进行排序，用 $cnt$ 表示元素所需的操作次数，初始时 $cnt=0$。
+
+遍历 $nums[1..n-1]$，如果当前元素 $nums[i]$ 不等于 $nums[i-1]$，则将 $cnt$ 加一。累加当前 $cnt$ 到答案 $ans$。
+
+时间复杂度 $O(nlogn)$。
 
 <!-- tabs:start -->
 
@@ -74,12 +80,22 @@
 class Solution:
     def reductionOperations(self, nums: List[int]) -> int:
         nums.sort()
-        cnt, res, n = 0, 0, len(nums)
-        for i in range(1, n):
-            if nums[i] != nums[i - 1]:
+        ans = cnt = 0
+        for i, v in enumerate(nums[1:]):
+            if v != nums[i]:
                 cnt += 1
-            res += cnt
-        return res
+            ans += cnt
+        return ans
+```
+
+```python
+class Solution:
+    def reductionOperations(self, nums: List[int]) -> int:
+        ans = cnt = 0
+        for _, v in sorted(Counter(nums).items()):
+            ans += cnt * v
+            cnt += 1
+        return ans
 ```
 
 ### **Java**
@@ -90,14 +106,31 @@ class Solution:
 class Solution {
     public int reductionOperations(int[] nums) {
         Arrays.sort(nums);
-        int cnt = 0, res = 0, n = nums.length;
-        for (int i = 1; i < n; ++i) {
+        int ans = 0, cnt = 0;
+        for (int i = 1; i < nums.length; ++i) {
             if (nums[i] != nums[i - 1]) {
                 ++cnt;
             }
-            res += cnt;
+            ans += cnt;
+        }
+        return ans;
+    }
+}
+```
+
+```java
+class Solution {
+    public int reductionOperations(int[] nums) {
+        Map<Integer, Integer> tm = new TreeMap<>();
+        for (int v : nums) {
+            tm.put(v, tm.getOrDefault(v, 0) + 1);
+        }
+        int ans = 0, cnt = 0;
+        for (int v : tm.values()) {
+            ans += cnt * v;
+            ++cnt;
         }
-        return res;
+        return ans;
     }
 }
 ```
@@ -107,14 +140,13 @@ class Solution {
 ```ts
 function reductionOperations(nums: number[]): number {
     nums.sort((a, b) => a - b);
-    let n = nums.length;
-    let ans = 0,
-        count = 0;
-    for (let i = 1; i < n; i++) {
+    let ans = 0;
+    let cnt = 0;
+    for (let i = 1; i < nums.length; ++i) {
         if (nums[i] != nums[i - 1]) {
-            count++;
+            ++cnt;
         }
-        ans += count;
+        ans += cnt;
     }
     return ans;
 }
@@ -127,12 +159,30 @@ class Solution {
 public:
     int reductionOperations(vector<int>& nums) {
         sort(nums.begin(), nums.end());
-        int cnt = 0, res = 0, n = nums.size();
-        for (int i = 1; i < n; ++i) {
-            if (nums[i] != nums[i - 1]) ++cnt;
-            res += cnt;
+        int ans = 0, cnt = 0;
+        for (int i = 1; i < nums.size(); ++i)
+        {
+            cnt += nums[i] != nums[i - 1];
+            ans += cnt;
+        }
+        return ans;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    int reductionOperations(vector<int>& nums) {
+        map<int, int> m;
+        for (int v : nums) ++m[v];
+        int ans = 0, cnt = 0;
+        for (auto [_, v] : m)
+        {
+            ans += cnt * v;
+            ++cnt;
         }
-        return res;
+        return ans;
     }
 };
 ```
@@ -142,14 +192,14 @@ public:
 ```go
 func reductionOperations(nums []int) int {
 	sort.Ints(nums)
-	cnt, res, n := 0, 0, len(nums)
-	for i := 1; i < n; i++ {
-		if nums[i] != nums[i-1] {
+	ans, cnt := 0, 0
+	for i, v := range nums[1:] {
+		if v != nums[i] {
 			cnt++
 		}
-		res += cnt
+		ans += cnt
 	}
-	return res
+	return ans
 }
 ```
 
diff --git a/solution/1800-1899/1887.Reduction Operations to Make the Array Elements Equal/README_EN.md b/solution/1800-1899/1887.Reduction Operations to Make the Array Elements Equal/README_EN.md
@@ -64,12 +64,22 @@
 class Solution:
     def reductionOperations(self, nums: List[int]) -> int:
         nums.sort()
-        cnt, res, n = 0, 0, len(nums)
-        for i in range(1, n):
-            if nums[i] != nums[i - 1]:
+        ans = cnt = 0
+        for i, v in enumerate(nums[1:]):
+            if v != nums[i]:
                 cnt += 1
-            res += cnt
-        return res
+            ans += cnt
+        return ans
+```
+
+```python
+class Solution:
+    def reductionOperations(self, nums: List[int]) -> int:
+        ans = cnt = 0
+        for _, v in sorted(Counter(nums).items()):
+            ans += cnt * v
+            cnt += 1
+        return ans
 ```
 
 ### **Java**
@@ -78,14 +88,31 @@ class Solution:
 class Solution {
     public int reductionOperations(int[] nums) {
         Arrays.sort(nums);
-        int cnt = 0, res = 0, n = nums.length;
-        for (int i = 1; i < n; ++i) {
+        int ans = 0, cnt = 0;
+        for (int i = 1; i < nums.length; ++i) {
             if (nums[i] != nums[i - 1]) {
                 ++cnt;
             }
-            res += cnt;
+            ans += cnt;
         }
-        return res;
+        return ans;
+    }
+}
+```
+
+```java
+class Solution {
+    public int reductionOperations(int[] nums) {
+        Map<Integer, Integer> tm = new TreeMap<>();
+        for (int v : nums) {
+            tm.put(v, tm.getOrDefault(v, 0) + 1);
+        }
+        int ans = 0, cnt = 0;
+        for (int v : tm.values()) {
+            ans += cnt * v;
+            ++cnt;
+        }
+        return ans;
     }
 }
 ```
@@ -95,14 +122,13 @@ class Solution {
 ```ts
 function reductionOperations(nums: number[]): number {
     nums.sort((a, b) => a - b);
-    let n = nums.length;
-    let ans = 0,
-        count = 0;
-    for (let i = 1; i < n; i++) {
+    let ans = 0;
+    let cnt = 0;
+    for (let i = 1; i < nums.length; ++i) {
         if (nums[i] != nums[i - 1]) {
-            count++;
+            ++cnt;
         }
-        ans += count;
+        ans += cnt;
     }
     return ans;
 }
@@ -115,12 +141,30 @@ class Solution {
 public:
     int reductionOperations(vector<int>& nums) {
         sort(nums.begin(), nums.end());
-        int cnt = 0, res = 0, n = nums.size();
-        for (int i = 1; i < n; ++i) {
-            if (nums[i] != nums[i - 1]) ++cnt;
-            res += cnt;
+        int ans = 0, cnt = 0;
+        for (int i = 1; i < nums.size(); ++i)
+        {
+            cnt += nums[i] != nums[i - 1];
+            ans += cnt;
+        }
+        return ans;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    int reductionOperations(vector<int>& nums) {
+        map<int, int> m;
+        for (int v : nums) ++m[v];
+        int ans = 0, cnt = 0;
+        for (auto [_, v] : m)
+        {
+            ans += cnt * v;
+            ++cnt;
         }
-        return res;
+        return ans;
     }
 };
 ```
@@ -130,14 +174,14 @@ public:
 ```go
 func reductionOperations(nums []int) int {
 	sort.Ints(nums)
-	cnt, res, n := 0, 0, len(nums)
-	for i := 1; i < n; i++ {
-		if nums[i] != nums[i-1] {
+	ans, cnt := 0, 0
+	for i, v := range nums[1:] {
+		if v != nums[i] {
 			cnt++
 		}
-		res += cnt
+		ans += cnt
 	}
-	return res
+	return ans
 }
 ```
 
diff --git a/solution/1800-1899/1887.Reduction Operations to Make the Array Elements Equal/Solution.cpp b/solution/1800-1899/1887.Reduction Operations to Make the Array Elements Equal/Solution.cpp
@@ -2,11 +2,12 @@ class Solution {
 public:
     int reductionOperations(vector<int>& nums) {
         sort(nums.begin(), nums.end());
-        int cnt = 0, res = 0, n = nums.size();
-        for (int i = 1; i < n; ++i) {
-            if (nums[i] != nums[i - 1]) ++cnt;
-            res += cnt;
+        int ans = 0, cnt = 0;
+        for (int i = 1; i < nums.size(); ++i)
+        {
+            cnt += nums[i] != nums[i - 1];
+            ans += cnt;
         }
-        return res;
+        return ans;
     }
 };
diff --git a/solution/1800-1899/1887.Reduction Operations to Make the Array Elements Equal/Solution.go b/solution/1800-1899/1887.Reduction Operations to Make the Array Elements Equal/Solution.go
@@ -1,11 +1,11 @@
 func reductionOperations(nums []int) int {
 	sort.Ints(nums)
-	cnt, res, n := 0, 0, len(nums)
-	for i := 1; i < n; i++ {
-		if nums[i] != nums[i-1] {
+	ans, cnt := 0, 0
+	for i, v := range nums[1:] {
+		if v != nums[i] {
 			cnt++
 		}
-		res += cnt
+		ans += cnt
 	}
-	return res
+	return ans
 }
diff --git a/solution/1800-1899/1887.Reduction Operations to Make the Array Elements Equal/Solution.java b/solution/1800-1899/1887.Reduction Operations to Make the Array Elements Equal/Solution.java
@@ -1,13 +1,13 @@
 class Solution {
     public int reductionOperations(int[] nums) {
         Arrays.sort(nums);
-        int cnt = 0, res = 0, n = nums.length;
-        for (int i = 1; i < n; ++i) {
+        int ans = 0, cnt = 0;
+        for (int i = 1; i < nums.length; ++i) {
             if (nums[i] != nums[i - 1]) {
                 ++cnt;
             }
-            res += cnt;
+            ans += cnt;
         }
-        return res;
+        return ans;
     }
 }
diff --git a/solution/1800-1899/1887.Reduction Operations to Make the Array Elements Equal/Solution.py b/solution/1800-1899/1887.Reduction Operations to Make the Array Elements Equal/Solution.py
@@ -1,9 +1,9 @@
 class Solution:
     def reductionOperations(self, nums: List[int]) -> int:
         nums.sort()
-        cnt, res, n = 0, 0, len(nums)
-        for i in range(1, n):
-            if nums[i] != nums[i - 1]:
+        ans = cnt = 0
+        for i, v in enumerate(nums[1:]):
+            if v != nums[i]:
                 cnt += 1
-            res += cnt
-        return res
+            ans += cnt
+        return ans
diff --git a/solution/1800-1899/1887.Reduction Operations to Make the Array Elements Equal/Solution.ts b/solution/1800-1899/1887.Reduction Operations to Make the Array Elements Equal/Solution.ts
@@ -1,13 +1,12 @@
 function reductionOperations(nums: number[]): number {
     nums.sort((a, b) => a - b);
-    let n = nums.length;
-    let ans = 0,
-        count = 0;
-    for (let i = 1; i < n; i++) {
+    let ans = 0;
+    let cnt = 0;
+    for (let i = 1; i < nums.length; ++i) {
         if (nums[i] != nums[i - 1]) {
-            count++;
+            ++cnt;
         }
-        ans += count;
+        ans += cnt;
     }
     return ans;
 }

Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,11 @@`
`1`	`1`	`func reductionOperations(nums []int) int {`
`2`	`2`	`sort.Ints(nums)`
`3`		`- cnt, res, n := 0, 0, len(nums)`
`4`		`- for i := 1; i < n; i++ {`
`5`		`- if nums[i] != nums[i-1] {`
	`3`	`+ ans, cnt := 0, 0`
	`4`	`+ for i, v := range nums[1:] {`
	`5`	`+ if v != nums[i] {`
`6`	`6`	`cnt++`
`7`	`7`	`}`
`8`		`- res += cnt`
	`8`	`+ ans += cnt`
`9`	`9`	`}`
`10`		`- return res`
	`10`	`+ return ans`
`11`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,13 @@`
`1`	`1`	`class Solution {`
`2`	`2`	`public int reductionOperations(int[] nums) {`
`3`	`3`	`Arrays.sort(nums);`
`4`		`- int cnt = 0, res = 0, n = nums.length;`
`5`		`- for (int i = 1; i < n; ++i) {`
	`4`	`+ int ans = 0, cnt = 0;`
	`5`	`+ for (int i = 1; i < nums.length; ++i) {`
`6`	`6`	`if (nums[i] != nums[i - 1]) {`
`7`	`7`	`++cnt;`
`8`	`8`	`}`
`9`		`- res += cnt;`
	`9`	`+ ans += cnt;`
`10`	`10`	`}`
`11`		`- return res;`
	`11`	`+ return ans;`
`12`	`12`	`}`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,12 @@`
`1`	`1`	`function reductionOperations(nums: number[]): number {`
`2`	`2`	`nums.sort((a, b) => a - b);`
`3`		`- let n = nums.length;`
`4`		`- let ans = 0,`
`5`		`- count = 0;`
`6`		`- for (let i = 1; i < n; i++) {`
	`3`	`+ let ans = 0;`
	`4`	`+ let cnt = 0;`
	`5`	`+ for (let i = 1; i < nums.length; ++i) {`
`7`	`6`	`if (nums[i] != nums[i - 1]) {`
`8`		`- count++;`
	`7`	`+ ++cnt;`
`9`	`8`	`}`
`10`		`- ans += count;`
	`9`	`+ ans += cnt;`
`11`	`10`	`}`
`12`	`11`	`return ans;`
`13`	`12`	`}`