feat: 使循环数组所有元素相等的最少秒数

README.md

@@ -165,6 +165,10 @@ Rust标准库`std::collections`提供了4种通用容器类型，包含一下8
 
 ### 数组/队列/集合/映射
 
+- [使循环数组所有元素相等的最少秒数](src/array/minimum_seconds_to_equalize_a_circular_array.rs)  [数组, 哈希表]
+
+  - LeetCode 2808. 使循环数组所有元素相等的最少秒数 <https://leetcode.cn/problems/minimum-seconds-to-equalize-a-circular-array>
+
 - [最长交替子数组](src/array/longest_alternating_subarray.rs)  [数组, 枚举]
 
   - LeetCode 2765. 最长交替子数组 <https://leetcode.cn/problems/longest-alternating-subarray>

src/array/minimum_seconds_to_equalize_a_circular_array.rs

@@ -0,0 +1,28 @@
+// 使循环数组所有元素相等的最少秒数
+// https://leetcode.cn/problems/minimum-seconds-to-equalize-a-circular-array
+// INLINE  ../../images/array/minimum_seconds_to_equalize_a_circular_array.jpeg
+
+pub struct Solution;
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn minimum_seconds(nums: Vec<i32>) -> i32 {
+        let mut map: HashMap<i32, Vec<usize>> = HashMap::new();
+        let n = nums.len();
+        let mut res = n;
+
+        for (i, num) in nums.iter().enumerate() {
+            map.entry(*num).or_insert(Vec::new()).push(i);
+        }
+
+        for pos in map.values() {
+            let mut mx = pos[0] + n - pos[pos.len() - 1];
+            for i in 1..pos.len() {
+                mx = mx.max(pos[i] - pos[i - 1]);
+            }
+            res = res.min(mx / 2);
+        }
+
+        res as i32
+    }
+}

src/array/mod.rs

@@ -59,3 +59,4 @@ pub mod find_maximum_number_of_string_pairs;
 pub mod split_strings_by_separator;
 pub mod split_array_largest_sum;
 pub mod longest_alternating_subarray;
+pub mod minimum_seconds_to_equalize_a_circular_array;

tests/array/minimum_seconds_to_equalize_a_circular_array_test.rs

@@ -0,0 +1,30 @@
+use rust_practice::array::minimum_seconds_to_equalize_a_circular_array::Solution;
+
+#[test]
+fn minimum_seconds() {
+    // 示例 1：
+    // 输入：nums = [1,2,1,2]
+    // 输出：1
+    // 解释：我们可以在 1 秒内将数组变成相等元素：
+    // - 第 1 秒，将每个位置的元素分别变为 [nums[3],nums[1],nums[3],nums[3]] 。变化后，nums = [2,2,2,2] 。
+    // 1 秒是将数组变成相等元素所需要的最少秒数。
+    let nums = vec![1, 2, 1, 2];
+    assert_eq!(Solution::minimum_seconds(nums), 1);
+
+    // 示例 2：
+    // 输入：nums = [2,1,3,3,2]
+    // 输出：2
+    // 解释：我们可以在 2 秒内将数组变成相等元素：
+    // - 第 1 秒，将每个位置的元素分别变为 [nums[0],nums[2],nums[2],nums[2],nums[3]] 。变化后，nums = [2,3,3,3,3] 。
+    // - 第 2 秒，将每个位置的元素分别变为 [nums[1],nums[1],nums[2],nums[3],nums[4]] 。变化后，nums = [3,3,3,3,3] 。
+    // 2 秒是将数组变成相等元素所需要的最少秒数。
+    let nums = vec![2, 1, 3, 3, 2];
+    assert_eq!(Solution::minimum_seconds(nums), 2);
+
+    // 示例 3：
+    // 输入：nums = [5,5,5,5]
+    // 输出：0
+    // 解释：不需要执行任何操作，因为一开始数组中的元素已经全部相等。
+    let nums = vec![5, 5, 5, 5];
+    assert_eq!(Solution::minimum_seconds(nums), 0);
+}

tests/array/mod.rs

@@ -59,3 +59,4 @@ pub mod find_maximum_number_of_string_pairs_test;
 pub mod split_strings_by_separator_test;
 pub mod split_array_largest_sum_test;
 pub mod longest_alternating_subarray_test;
+pub mod minimum_seconds_to_equalize_a_circular_array_test;