feat: add solutions to lc problem: No.0907 (doocs#2021)

No.0907.Sum of Subarray Minimums

Author: yanglbme

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

@@ -73,7 +73,7 @@
 
 注意数据的溢出以及取模操作。
 
-时间复杂度 $O(n)$，其中 $n$ 表示数组 $arr$ 的长度。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $arr$ 的长度。
 
 <!-- tabs:start -->
 
@@ -138,7 +138,7 @@ class Solution {
             }
             stk.push(i);
         }
-        int mod = (int) 1e9 + 7;
+        final int mod = (int) 1e9 + 7;
         long ans = 0;
         for (int i = 0; i < n; ++i) {
             ans += (long) (i - left[i]) * (right[i] - i) % mod * arr[i] % mod;
@@ -152,9 +152,6 @@ class Solution {
 ### **C++**
 
 ```cpp
-using ll = long long;
-const int mod = 1e9 + 7;
-
 class Solution {
 public:
     int sumSubarrayMins(vector<int>& arr) {
@@ -163,28 +160,160 @@ public:
         vector<int> right(n, n);
         stack<int> stk;
         for (int i = 0; i < n; ++i) {
-            while (!stk.empty() && arr[stk.top()] >= arr[i]) stk.pop();
-            if (!stk.empty()) left[i] = stk.top();
+            while (!stk.empty() && arr[stk.top()] >= arr[i]) {
+                stk.pop();
+            }
+            if (!stk.empty()) {
+                left[i] = stk.top();
+            }
             stk.push(i);
         }
         stk = stack<int>();
         for (int i = n - 1; i >= 0; --i) {
-            while (!stk.empty() && arr[stk.top()] > arr[i]) stk.pop();
-            if (!stk.empty()) right[i] = stk.top();
+            while (!stk.empty() && arr[stk.top()] > arr[i]) {
+                stk.pop();
+            }
+            if (!stk.empty()) {
+                right[i] = stk.top();
+            }
             stk.push(i);
         }
-        ll ans = 0;
+        long long ans = 0;
+        const int mod = 1e9 + 7;
         for (int i = 0; i < n; ++i) {
-            ans += (ll) (i - left[i]) * (right[i] - i) * arr[i] % mod;
+            ans += 1LL * (i - left[i]) * (right[i] - i) * arr[i] % mod;
             ans %= mod;
         }
         return ans;
     }
 };
 ```
 
+### **Go**
+
+```go
+func sumSubarrayMins(arr []int) (ans int) {
+	n := len(arr)
+	left := make([]int, n)
+	right := make([]int, n)
+	for i := range left {
+		left[i] = -1
+		right[i] = n
+	}
+	stk := []int{}
+	for i, v := range arr {
+		for len(stk) > 0 && arr[stk[len(stk)-1]] >= v {
+			stk = stk[:len(stk)-1]
+		}
+		if len(stk) > 0 {
+			left[i] = stk[len(stk)-1]
+		}
+		stk = append(stk, i)
+	}
+	stk = []int{}
+	for i := n - 1; i >= 0; i-- {
+		for len(stk) > 0 && arr[stk[len(stk)-1]] > arr[i] {
+			stk = stk[:len(stk)-1]
+		}
+		if len(stk) > 0 {
+			right[i] = stk[len(stk)-1]
+		}
+		stk = append(stk, i)
+	}
+	const mod int = 1e9 + 7
+	for i, v := range arr {
+		ans += (i - left[i]) * (right[i] - i) * v % mod
+		ans %= mod
+	}
+	return
+}
+```
+
+### **TypeScript**
+
+```ts
+function sumSubarrayMins(arr: number[]): number {
+    const n: number = arr.length;
+    const left: number[] = Array(n).fill(-1);
+    const right: number[] = Array(n).fill(n);
+    const stk: number[] = [];
+    for (let i = 0; i < n; ++i) {
+        while (stk.length > 0 && arr[stk.at(-1)] >= arr[i]) {
+            stk.pop();
+        }
+        if (stk.length > 0) {
+            left[i] = stk.at(-1);
+        }
+        stk.push(i);
+    }
+
+    stk.length = 0;
+    for (let i = n - 1; ~i; --i) {
+        while (stk.length > 0 && arr[stk.at(-1)] > arr[i]) {
+            stk.pop();
+        }
+        if (stk.length > 0) {
+            right[i] = stk.at(-1);
+        }
+        stk.push(i);
+    }
+
+    const mod: number = 1e9 + 7;
+    let ans: number = 0;
+    for (let i = 0; i < n; ++i) {
+        ans += ((((i - left[i]) * (right[i] - i)) % mod) * arr[i]) % mod;
+        ans %= mod;
+    }
+    return ans;
+}
+```
+
 ### **Rust**
 
+```rust
+use std::collections::VecDeque;
+
+impl Solution {
+    pub fn sum_subarray_mins(arr: Vec<i32>) -> i32 {
+        let n = arr.len();
+        let mut left = vec![-1; n];
+        let mut right = vec![n as i32; n];
+        let mut stk: VecDeque<usize> = VecDeque::new();
+
+        for i in 0..n {
+            while !stk.is_empty() && arr[*stk.back().unwrap()] >= arr[i] {
+                stk.pop_back();
+            }
+            if let Some(&top) = stk.back() {
+                left[i] = top as i32;
+            }
+            stk.push_back(i);
+        }
+
+        stk.clear();
+        for i in (0..n).rev() {
+            while !stk.is_empty() && arr[*stk.back().unwrap()] > arr[i] {
+                stk.pop_back();
+            }
+            if let Some(&top) = stk.back() {
+                right[i] = top as i32;
+            }
+            stk.push_back(i);
+        }
+
+        let MOD = 1_000_000_007;
+        let mut ans: i64 = 0;
+        for i in 0..n {
+            ans +=
+                ((((right[i] - (i as i32)) * ((i as i32) - left[i])) as i64) * (arr[i] as i64)) %
+                MOD;
+            ans %= MOD;
+        }
+        ans as i32
+    }
+}
+```
+
 ```rust
 const MOD: i64 = (1e9 as i64) + 7;
 
@@ -236,70 +365,6 @@ impl Solution {
 }
 ```
 
-### **Go**
-
-```go
-func sumSubarrayMins(arr []int) int {
-	mod := int(1e9) + 7
-	n := len(arr)
-	left := make([]int, n)
-	right := make([]int, n)
-	for i := range left {
-		left[i] = -1
-		right[i] = n
-	}
-	stk := []int{}
-	for i, v := range arr {
-		for len(stk) > 0 && arr[stk[len(stk)-1]] >= v {
-			stk = stk[:len(stk)-1]
-		}
-		if len(stk) > 0 {
-			left[i] = stk[len(stk)-1]
-		}
-		stk = append(stk, i)
-	}
-	stk = []int{}
-	for i := n - 1; i >= 0; i-- {
-		for len(stk) > 0 && arr[stk[len(stk)-1]] > arr[i] {
-			stk = stk[:len(stk)-1]
-		}
-		if len(stk) > 0 {
-			right[i] = stk[len(stk)-1]
-		}
-		stk = append(stk, i)
-	}
-	ans := 0
-	for i, v := range arr {
-		ans += (i - left[i]) * (right[i] - i) * v % mod
-		ans %= mod
-	}
-	return ans
-}
-```
-
-### **TypeScript**
-
-```ts
-function sumSubarrayMins(arr: number[]): number {
-    const n = arr.length;
-    function getEle(i: number): number {
-        if (i == -1 || i == n) return Number.MIN_SAFE_INTEGER;
-        return arr[i];
-    }
-    let ans = 0;
-    const mod = 10 ** 9 + 7;
-    let stack = [];
-    for (let i = -1; i <= n; i++) {
-        while (stack.length && getEle(stack[0]) > getEle(i)) {
-            const idx = stack.shift();
-            ans = (ans + arr[idx] * (idx - stack[0]) * (i - idx)) % mod;
-        }
-        stack.unshift(i);
-    }
-    return ans;
-}
-```
-
 ### **...**
 
 ```