feat: add solutions to lc problems (doocs#2438)

Author: yanglbme

solution/2500-2599/2549.Count Distinct Numbers on Board/README.md

@@ -59,7 +59,7 @@
 
 ### 方法一：脑筋急转弯
 
-由于每一次对桌面上的数字 $n$ 进行操作，会使得数字 $n-1$ 也出现在桌面上，因此最终桌面上的数字为 $[2,...n]$，即 $n-1$ 个数字。
+由于每一次对桌面上的数字 $n$ 进行操作，会使得数字 $n-1$ 也出现在桌面上，因此最终桌面上的数字为 $[2,...n]$，共 $n-1$ 个数字。
 
 注意到 $n$ 可能为 $1$，因此需要特判。
 
@@ -92,10 +92,7 @@ public:
 
 ```go
 func distinctIntegers(n int) int {
-	if n == 1 {
-		return 1
-	}
-	return n - 1
+	return max(1, n-1)
 }
 ```
 
@@ -108,11 +105,7 @@ function distinctIntegers(n: number): number {
 ```rust
 impl Solution {
     pub fn distinct_integers(n: i32) -> i32 {
-        if n == 1 {
-            return 1;
-        }
-
-        n - 1
+        (1).max(n - 1)
     }
 }
 ```

solution/2500-2599/2549.Count Distinct Numbers on Board/README_EN.md

@@ -88,10 +88,7 @@ public:
 
 ```go
 func distinctIntegers(n int) int {
-	if n == 1 {
-		return 1
-	}
-	return n - 1
+	return max(1, n-1)
 }
 ```
 
@@ -104,11 +101,7 @@ function distinctIntegers(n: number): number {
 ```rust
 impl Solution {
     pub fn distinct_integers(n: i32) -> i32 {
-        if n == 1 {
-            return 1;
-        }
-
-        n - 1
+        (1).max(n - 1)
     }
 }
 ```

solution/2500-2599/2549.Count Distinct Numbers on Board/Solution.go

@@ -1,6 +1,3 @@
 func distinctIntegers(n int) int {
-	if n == 1 {
-		return 1
-	}
-	return n - 1
+	return max(1, n-1)
 }

solution/2500-2599/2549.Count Distinct Numbers on Board/Solution.rs

@@ -1,9 +1,5 @@
 impl Solution {
     pub fn distinct_integers(n: i32) -> i32 {
-        if n == 1 {
-            return 1;
-        }
-
-        n - 1
+        (1).max(n - 1)
     }
 }

solution/2600-2699/2671.Frequency Tracker/README.md

@@ -274,6 +274,61 @@ class FrequencyTracker {
  */
 ```
 
+```rust
+use std::collections::HashMap;
+
+struct FrequencyTracker {
+    cnt: HashMap<i32, i32>,
+    freq: HashMap<i32, i32>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl FrequencyTracker {
+    fn new() -> Self {
+        FrequencyTracker {
+            cnt: HashMap::new(),
+            freq: HashMap::new(),
+        }
+    }
+
+    fn add(&mut self, number: i32) {
+        let count = self.cnt.entry(number).or_insert(0);
+        let prev_freq = self.freq.entry(*count).or_insert(0);
+        *prev_freq -= 1;
+        *count += 1;
+        let new_freq = self.freq.entry(*count).or_insert(0);
+        *new_freq += 1;
+    }
+
+    fn delete_one(&mut self, number: i32) {
+        if let Some(count) = self.cnt.get_mut(&number) {
+            if *count > 0 {
+                if let Some(prev_freq) = self.freq.get_mut(count) {
+                    *prev_freq -= 1;
+                }
+                *count -= 1;
+                if let Some(new_freq) = self.freq.get_mut(count) {
+                    *new_freq += 1;
+                }
+            }
+        }
+    }
+
+    fn has_frequency(&self, frequency: i32) -> bool {
+        self.freq.get(&frequency).map_or(false, |&freq| freq > 0)
+    }
+}/**
+ * Your FrequencyTracker object will be instantiated and called as such:
+ * let obj = FrequencyTracker::new();
+ * obj.add(number);
+ * obj.delete_one(number);
+ * let ret_3: bool = obj.has_frequency(frequency);
+ */
+```
+
 <!-- tabs:end -->
 
 <!-- end -->

solution/2600-2699/2671.Frequency Tracker/README_EN.md

@@ -273,6 +273,61 @@ class FrequencyTracker {
  */
 ```
 
+```rust
+use std::collections::HashMap;
+
+struct FrequencyTracker {
+    cnt: HashMap<i32, i32>,
+    freq: HashMap<i32, i32>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl FrequencyTracker {
+    fn new() -> Self {
+        FrequencyTracker {
+            cnt: HashMap::new(),
+            freq: HashMap::new(),
+        }
+    }
+
+    fn add(&mut self, number: i32) {
+        let count = self.cnt.entry(number).or_insert(0);
+        let prev_freq = self.freq.entry(*count).or_insert(0);
+        *prev_freq -= 1;
+        *count += 1;
+        let new_freq = self.freq.entry(*count).or_insert(0);
+        *new_freq += 1;
+    }
+
+    fn delete_one(&mut self, number: i32) {
+        if let Some(count) = self.cnt.get_mut(&number) {
+            if *count > 0 {
+                if let Some(prev_freq) = self.freq.get_mut(count) {
+                    *prev_freq -= 1;
+                }
+                *count -= 1;
+                if let Some(new_freq) = self.freq.get_mut(count) {
+                    *new_freq += 1;
+                }
+            }
+        }
+    }
+
+    fn has_frequency(&self, frequency: i32) -> bool {
+        self.freq.get(&frequency).map_or(false, |&freq| freq > 0)
+    }
+}/**
+ * Your FrequencyTracker object will be instantiated and called as such:
+ * let obj = FrequencyTracker::new();
+ * obj.add(number);
+ * obj.delete_one(number);
+ * let ret_3: bool = obj.has_frequency(frequency);
+ */
+```
+
 <!-- tabs:end -->
 
 <!-- end -->

solution/2600-2699/2671.Frequency Tracker/Solution.rs

@@ -0,0 +1,52 @@
+use std::collections::HashMap;
+
+struct FrequencyTracker {
+    cnt: HashMap<i32, i32>,
+    freq: HashMap<i32, i32>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl FrequencyTracker {
+    fn new() -> Self {
+        FrequencyTracker {
+            cnt: HashMap::new(),
+            freq: HashMap::new(),
+        }
+    }
+
+    fn add(&mut self, number: i32) {
+        let count = self.cnt.entry(number).or_insert(0);
+        let prev_freq = self.freq.entry(*count).or_insert(0);
+        *prev_freq -= 1;
+        *count += 1;
+        let new_freq = self.freq.entry(*count).or_insert(0);
+        *new_freq += 1;
+    }
+
+    fn delete_one(&mut self, number: i32) {
+        if let Some(count) = self.cnt.get_mut(&number) {
+            if *count > 0 {
+                if let Some(prev_freq) = self.freq.get_mut(count) {
+                    *prev_freq -= 1;
+                }
+                *count -= 1;
+                if let Some(new_freq) = self.freq.get_mut(count) {
+                    *new_freq += 1;
+                }
+            }
+        }
+    }
+
+    fn has_frequency(&self, frequency: i32) -> bool {
+        self.freq.get(&frequency).map_or(false, |&freq| freq > 0)
+    }
+}/**
+ * Your FrequencyTracker object will be instantiated and called as such:
+ * let obj = FrequencyTracker::new();
+ * obj.add(number);
+ * obj.delete_one(number);
+ * let ret_3: bool = obj.has_frequency(frequency);
+ */

solution/2700-2799/2789.Largest Element in an Array after Merge Operations/README.md

@@ -52,7 +52,15 @@
 
 ## 解法
 
-### 方法一
+### 方法一：倒序合并
+
+根据题目描述，为了最大化合并后的数组中的最大元素，我们应该先合并右侧的元素，使得右侧的元素尽可能大，从而尽可能多地执行合并操作，最终得到最大的元素。
+
+因此，我们可以从右向左遍历数组，对于每个位置 $i$，其中 $i \in [0, n - 2]$，如果 $nums[i] \leq nums[i + 1]$，我们就将 $nums[i]$ 更新为 $nums[i] + nums[i + 1]$。这样做，相当于将 $nums[i]$ 与 $nums[i + 1]$ 合并，并且删掉 $nums[i]$。
+
+最终，数组中的最大元素就是合并后的数组中的最大元素。
+
+时间复杂度 $O(n)$，其中 $n$ 为数组的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/2700-2799/2789.Largest Element in an Array after Merge Operations/README_EN.md

@@ -50,7 +50,15 @@ There is only one element in the final array, which is 11.
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Merge in Reverse Order
+
+According to the problem description, in order to maximize the maximum element in the merged array, we should merge the elements on the right first, making the elements on the right as large as possible, so as to perform as many merge operations as possible and finally get the maximum element.
+
+Therefore, we can traverse the array from right to left. For each position $i$, where $i \in [0, n - 2]$, if $nums[i] \leq nums[i + 1]$, we update $nums[i]$ to $nums[i] + nums[i + 1]$. Doing so is equivalent to merging $nums[i]$ and $nums[i + 1]$ and deleting $nums[i]$.
+
+In the end, the maximum element in the array is the maximum element in the merged array.
+
+The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 

solution/2800-2899/2864.Maximum Odd Binary Number/README.md

@@ -64,12 +64,7 @@ class Solution:
 ```java
 class Solution {
     public String maximumOddBinaryNumber(String s) {
-        int cnt = 0;
-        for (char c : s.toCharArray()) {
-            if (c == '1') {
-                ++cnt;
-            }
-        }
+        int cnt = s.length() - s.replace("1", "").length();
         return "1".repeat(cnt - 1) + "0".repeat(s.length() - cnt) + "1";
     }
 }
@@ -79,16 +74,8 @@ class Solution {
 class Solution {
 public:
     string maximumOddBinaryNumber(string s) {
-        int cnt = count_if(s.begin(), s.end(), [](char c) { return c == '1'; });
-        string ans;
-        for (int i = 1; i < cnt; ++i) {
-            ans.push_back('1');
-        }
-        for (int i = 0; i < s.size() - cnt; ++i) {
-            ans.push_back('0');
-        }
-        ans.push_back('1');
-        return ans;
+        int cnt = count(s.begin(), s.end(), '1');
+        return string(cnt - 1, '1') + string(s.size() - cnt, '0') + '1';
     }
 };
 ```
@@ -102,14 +89,23 @@ func maximumOddBinaryNumber(s string) string {
 
 ```ts
 function maximumOddBinaryNumber(s: string): string {
-    let cnt = 0;
-    for (const c of s) {
-        cnt += c === '1' ? 1 : 0;
-    }
+    const cnt = s.length - s.replace(/1/g, '').length;
     return '1'.repeat(cnt - 1) + '0'.repeat(s.length - cnt) + '1';
 }
 ```
 
+```rust
+impl Solution {
+    pub fn maximum_odd_binary_number(s: String) -> String {
+        let cnt = s
+            .chars()
+            .filter(|&c| c == '1')
+            .count();
+        "1".repeat(cnt - 1) + &"0".repeat(s.len() - cnt) + "1"
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->