feat: add rust solution to lc problem: No.3542

Author: yanglbme

solution/3500-3599/3542.Minimum Operations to Convert All Elements to Zero/README.md

@@ -96,7 +96,18 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：单调栈
+
+根据题意，我们应该把数字中最小的数先变成 $0$，再把次小的数变成 $0$，依此类推。在这里过程中，如果两个数之间有更小的数隔开，那么它们需要额外的一次操作才能变成 $0$。
+
+我们可以维护一个从栈底到栈顶单调递增的栈 $\textit{stk}$，遍历数组 $\textit{nums}$ 中的每个数 $\textit{x}$：
+
+-   当栈顶元素大于 $\textit{x}$ 时，说明 $\textit{x}$ 将栈顶元素隔开了，我们需要把栈顶元素弹出，并将答案加 $1$，直到栈顶元素不大于 $\textit{x}$ 为止。
+-   如果 $\textit{x}$ 不为 $0$，且栈为空或者栈顶元素不等于 $\textit{x}$，则将 $\textit{x}$ 入栈。
+
+遍历结束后，栈中剩余的元素都需要额外的一次操作才能变成 $0$，因此我们将答案加上栈的大小即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$，其中 $n$ 是数组 $\textit{nums}$ 的长度。
 
 <!-- tabs:start -->
 
@@ -202,6 +213,32 @@ function minOperations(nums: number[]): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn min_operations(nums: Vec<i32>) -> i32 {
+        let mut stk = Vec::new();
+        let mut ans = 0;
+        for &x in nums.iter() {
+            while let Some(&last) = stk.last() {
+                if last > x {
+                    ans += 1;
+                    stk.pop();
+                } else {
+                    break;
+                }
+            }
+            if x != 0 && (stk.is_empty() || *stk.last().unwrap() != x) {
+                stk.push(x);
+            }
+        }
+        ans += stk.len() as i32;
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3500-3599/3542.Minimum Operations to Convert All Elements to Zero/README_EN.md

@@ -93,7 +93,18 @@ tags:
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Monotonic Stack
+
+According to the problem description, we should first convert the smallest numbers to $0$, then the second smallest numbers to $0$, and so on. During this process, if two numbers are separated by smaller numbers, they require an additional operation to become $0$.
+
+We can maintain a monotonically increasing stack $\textit{stk}$ from bottom to top, and traverse each number $\textit{x}$ in the array $\textit{nums}$:
+
+-   When the top element of the stack is greater than $\textit{x}$, it means $\textit{x}$ separates the top element. We need to pop the top element and increment the answer by $1$, continuing until the top element is not greater than $\textit{x}$.
+-   If $\textit{x}$ is not $0$, and the stack is empty or the top element is not equal to $\textit{x}$, then push $\textit{x}$ onto the stack.
+
+After traversal, the remaining elements in the stack all require an additional operation to become $0$, so we add the size of the stack to the answer.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the array $\textit{nums}$.
 
 <!-- tabs:start -->
 
@@ -199,6 +210,32 @@ function minOperations(nums: number[]): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn min_operations(nums: Vec<i32>) -> i32 {
+        let mut stk = Vec::new();
+        let mut ans = 0;
+        for &x in nums.iter() {
+            while let Some(&last) = stk.last() {
+                if last > x {
+                    ans += 1;
+                    stk.pop();
+                } else {
+                    break;
+                }
+            }
+            if x != 0 && (stk.is_empty() || *stk.last().unwrap() != x) {
+                stk.push(x);
+            }
+        }
+        ans += stk.len() as i32;
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3500-3599/3542.Minimum Operations to Convert All Elements to Zero/Solution.rs

@@ -0,0 +1,21 @@
+impl Solution {
+    pub fn min_operations(nums: Vec<i32>) -> i32 {
+        let mut stk = Vec::new();
+        let mut ans = 0;
+        for &x in nums.iter() {
+            while let Some(&last) = stk.last() {
+                if last > x {
+                    ans += 1;
+                    stk.pop();
+                } else {
+                    break;
+                }
+            }
+            if x != 0 && (stk.is_empty() || *stk.last().unwrap() != x) {
+                stk.push(x);
+            }
+        }
+        ans += stk.len() as i32;
+        ans
+    }
+}