feat: add rust solution to lc problem: No.0907 (doocs#1128)

Author: xzhseh

solution/0900-0999/0907.Sum of Subarray Minimums/README.md

@@ -183,6 +183,57 @@ public:
 };
 ```
 
+### **Rust**
+
+```rust
+const MOD: i64 = 1e9 as i64 + 7;
+
+impl Solution {
+    pub fn sum_subarray_mins(arr: Vec<i32>) -> i32 {
+        let n: usize = arr.len();
+        let mut ret: i64 = 0;
+        let mut left: Vec<i32> = vec![-1; n];
+        let mut right: Vec<i32> = vec![n as i32; n];
+        // Index stack, store the index of the value in the given array
+        let mut stack: Vec<i32> = Vec::new();
+
+        // Find the first element that's less than the current value for the left side
+        // The default value of which is -1
+        for i in 0..n {
+            while !stack.is_empty() && arr[*stack.last().unwrap() as usize] >= arr[i] {
+                stack.pop();
+            }
+            if !stack.is_empty() {
+                left[i] = *stack.last().unwrap();
+            }
+            stack.push(i as i32);
+        }
+
+        stack.clear();
+
+        // Find the first element that's less or equal than the current value for the right side
+        // The default value of which is n
+        for i in (0..n).rev() {
+            while !stack.is_empty() && arr[*stack.last().unwrap() as usize] > arr[i] {
+                stack.pop();
+            }
+            if !stack.is_empty() {
+                right[i] = *stack.last().unwrap();
+            }
+            stack.push(i as i32);
+        }
+
+        // Traverse the array, to find the sum
+        for i in 0..n {
+            ret += ((right[i] - i as i32) * (i as i32 - left[i])) as i64 * arr[i] as i64 % MOD;
+            ret %= MOD;
+        }
+
+        (ret % MOD as i64) as i32
+    }
+}
+```
+
 ### **Go**
 
 ```go

solution/0900-0999/0907.Sum of Subarray Minimums/README_EN.md

@@ -35,6 +35,50 @@ Sum is 17.
 
 ## Solutions
 
+The problem asks for the sum of the minimum values of each subarray, which is actually equivalent to finding the number of subarrays for each element $arr[i]$ where $arr[i]$ is the minimum, multiplying each by $arr[i]$, and then summing these products.
+
+Thus, the focus of the problem is translated to finding the number of subarrays for which $arr[i]$ is the minimum. 
+
+For each $arr[i]$, we identify the first position $left[i]$ to its left that is smaller than $arr[i]$ and the first position $right[i]$ to its right that is less than or equal to $arr[i]$. 
+
+The number of subarrays where $arr[i]$ is the minimum can then be given by $(i - left[i]) \times (right[i] - i)$.
+
+It's important to note why we are looking for the first position $right[i]$ that is less than or equal to $arr[i]$ and not less than $arr[i]$. 
+
+If we were to look for the first position less than $arr[i]$, we would end up double-counting.
+
+For instance, consider the following array:
+
+The element at index $3$ is $2$, and the first element less than $2$ to its left is at index $0$. If we find the first element less than $2$ to its right, we would end up at index $7$. That means the subarray interval is $(0, 7)$. Note that this is an open interval.
+
+```
+0 4 3 2 5 3 2 1
+*     ^       *
+```
+
+If we calculate the subarray interval for the element at index $6$ using the same method, we would find that its interval is also $(0, 7)$. 
+
+```
+0 4 3 2 5 3 2 1
+*           ^ *
+```
+
+Therefore, the subarray intervals of the elements at index $3$ and $6$ are overlapping, leading to double-counting.
+
+If we were to find the first element less than or equal to $arr[i]$ to its right, we wouldn't have this problem. 
+
+The subarray interval for the element at index $3$ would become $(0, 6)$ and for the element at index $6$ it would be $(0, 7)$, and these two are not overlapping.
+
+To solve this problem, we just need to traverse the array. 
+
+For each element $arr[i]$, we use a monotonic stack to find its $left[i]$ and $right[i]$. 
+
+Then the number of subarrays where $arr[i]$ is the minimum can be calculated by $(i - left[i]) \times (right[i] - i)$. Multiply this by $arr[i]$ and sum these values for all $i$ to get the final answer.
+
+Remember to take care of data overflow and modulus operation.
+
+The time complexity is $O(n)$, where $n$ represents the length of the array $arr$.
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -139,6 +183,57 @@ public:
 };
 ```
 
+### **Rust**
+
+```rust
+const MOD: i64 = 1e9 as i64 + 7;
+
+impl Solution {
+    pub fn sum_subarray_mins(arr: Vec<i32>) -> i32 {
+        let n: usize = arr.len();
+        let mut ret: i64 = 0;
+        let mut left: Vec<i32> = vec![-1; n];
+        let mut right: Vec<i32> = vec![n as i32; n];
+        // Index stack, store the index of the value in the given array
+        let mut stack: Vec<i32> = Vec::new();
+
+        // Find the first element that's less than the current value for the left side
+        // The default value of which is -1
+        for i in 0..n {
+            while !stack.is_empty() && arr[*stack.last().unwrap() as usize] >= arr[i] {
+                stack.pop();
+            }
+            if !stack.is_empty() {
+                left[i] = *stack.last().unwrap();
+            }
+            stack.push(i as i32);
+        }
+
+        stack.clear();
+
+        // Find the first element that's less or equal than the current value for the right side
+        // The default value of which is n
+        for i in (0..n).rev() {
+            while !stack.is_empty() && arr[*stack.last().unwrap() as usize] > arr[i] {
+                stack.pop();
+            }
+            if !stack.is_empty() {
+                right[i] = *stack.last().unwrap();
+            }
+            stack.push(i as i32);
+        }
+
+        // Traverse the array, to find the sum
+        for i in 0..n {
+            ret += ((right[i] - i as i32) * (i as i32 - left[i])) as i64 * arr[i] as i64 % MOD;
+            ret %= MOD;
+        }
+
+        (ret % MOD as i64) as i32
+    }
+}
+```
+
 ### **Go**
 
 ```go

solution/0900-0999/0907.Sum of Subarray Minimums/Solution.rs

@@ -0,0 +1,46 @@
+const MOD: i64 = 1e9 as i64 + 7;
+
+impl Solution {
+    pub fn sum_subarray_mins(arr: Vec<i32>) -> i32 {
+        let n: usize = arr.len();
+        let mut ret: i64 = 0;
+        let mut left: Vec<i32> = vec![-1; n];
+        let mut right: Vec<i32> = vec![n as i32; n];
+        // Index stack, store the index of the value in the given array
+        let mut stack: Vec<i32> = Vec::new();
+
+        // Find the first element that's less than the current value for the left side
+        // The default value of which is -1
+        for i in 0..n {
+            while !stack.is_empty() && arr[*stack.last().unwrap() as usize] >= arr[i] {
+                stack.pop();
+            }
+            if !stack.is_empty() {
+                left[i] = *stack.last().unwrap();
+            }
+            stack.push(i as i32);
+        }
+
+        stack.clear();
+
+        // Find the first element that's less or equal than the current value for the right side
+        // The default value of which is n
+        for i in (0..n).rev() {
+            while !stack.is_empty() && arr[*stack.last().unwrap() as usize] > arr[i] {
+                stack.pop();
+            }
+            if !stack.is_empty() {
+                right[i] = *stack.last().unwrap();
+            }
+            stack.push(i as i32);
+        }
+
+        // Traverse the array, to find the sum
+        for i in 0..n {
+            ret += ((right[i] - i as i32) * (i as i32 - left[i])) as i64 * arr[i] as i64 % MOD;
+            ret %= MOD;
+        }
+
+        (ret % MOD as i64) as i32
+    }
+}