feat: add solutions to lc problems: No.0670,3010 (doocs#2245)

* No.0670.Maximum Swap
* No.3010.Divide an Array Into Subarrays With Minimum Cost I

Author: yanglbme

solution/0600-0699/0670.Maximum Swap/README.md

@@ -34,13 +34,13 @@
 
 ### 方法一：贪心
 
-先将数字转为字符串 `s`，然后从右往左遍历字符串 `s`，用数组或哈希表 `d` 记录每个数字右侧的最大数字的位置（可以是字符本身的位置）。
+我们先将数字转为字符串 $s$，然后从右往左遍历字符串 $s$，用数组或哈希表 $d$ 记录每个数字右侧的最大数字的位置（可以是数字本身的位置）。
 
-接着从左到右遍历 `d`，如果 `s[i] < s[d[i]]`，则进行交换，并退出遍历的过程。
+接着从左到右遍历 $d$，如果 $s[i] \lt s[d[i]]$，则进行交换，并退出遍历的过程。
 
-最后将字符串 `s` 转为数字，即为答案。
+最后将字符串 $s$ 转为数字，即为答案。
 
-时间复杂度 $O(\log C)$，空间复杂度 $O(\log C)$。其中 $C$ 是数字 `num` 的值域。
+时间复杂度 $O(\log M)$，空间复杂度 $O(\log M)$。其中 $M$ 是数字 $num$ 的取值范围。
 
 <!-- tabs:start -->
 

solution/0600-0699/0670.Maximum Swap/README_EN.md

@@ -34,7 +34,15 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Greedy Algorithm
+
+First, we convert the number into a string $s$. Then, we traverse the string $s$ from right to left, using an array or hash table $d$ to record the position of the maximum number to the right of each number (it can be the position of the number itself).
+
+Next, we traverse $d$ from left to right. If $s[i] < s[d[i]]$, we swap them and exit the traversal process.
+
+Finally, we convert the string $s$ back into a number, which is the answer.
+
+The time complexity is $O(\log M)$, and the space complexity is $O(\log M)$. Here, $M$ is the range of the number $num$.
 
 <!-- tabs:start -->
 

solution/3000-3099/3010.Divide an Array Into Subarrays With Minimum Cost I/README.md

@@ -56,24 +56,87 @@
 
 ## 解法
 
-### 方法一
+### 方法一：遍历找最小值和次小值
+
+我们记数组 $nums$ 的第一个元素为 $a$，其余元素中最小的元素为 $b$，次小的元素为 $c$，那么答案就是 $a+b+c$。
+
+时间复杂度 $O(n)$，其中 $n$ 是数组 $nums$ 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
 ```python
-
+class Solution:
+    def minimumCost(self, nums: List[int]) -> int:
+        a, b, c = nums[0], inf, inf
+        for x in nums[1:]:
+            if x < b:
+                c, b = b, x
+            elif x < c:
+                c = x
+        return a + b + c
 ```
 
 ```java
-
+class Solution {
+    public int minimumCost(int[] nums) {
+        int a = nums[0], b = 100, c = 100;
+        for (int i = 1; i < nums.length; ++i) {
+            if (nums[i] < b) {
+                c = b;
+                b = nums[i];
+            } else if (nums[i] < c) {
+                c = nums[i];
+            }
+        }
+        return a + b + c;
+    }
+}
 ```
 
 ```cpp
-
+class Solution {
+public:
+    int minimumCost(vector<int>& nums) {
+        int a = nums[0], b = 100, c = 100;
+        for (int i = 1; i < nums.size(); ++i) {
+            if (nums[i] < b) {
+                c = b;
+                b = nums[i];
+            } else if (nums[i] < c) {
+                c = nums[i];
+            }
+        }
+        return a + b + c;
+    }
+};
 ```
 
 ```go
+func minimumCost(nums []int) int {
+	a, b, c := nums[0], 100, 100
+	for _, x := range nums[1:] {
+		if x < b {
+			b, c = x, b
+		} else if x < c {
+			c = x
+		}
+	}
+	return a + b + c
+}
+```
 
+```ts
+function minimumCost(nums: number[]): number {
+    let [a, b, c] = [nums[0], 100, 100];
+    for (const x of nums.slice(1)) {
+        if (x < b) {
+            [b, c] = [x, b];
+        } else if (x < c) {
+            c = x;
+        }
+    }
+    return a + b + c;
+}
 ```
 
 <!-- tabs:end -->

solution/3000-3099/3010.Divide an Array Into Subarrays With Minimum Cost I/README_EN.md

@@ -52,24 +52,87 @@ It can be shown that 12 is the minimum cost achievable.
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Traverse to Find the Smallest and Second Smallest Values
+
+We set the first element of the array $nums$ as $a$, the smallest element among the remaining elements as $b$, and the second smallest element as $c$. The answer is $a+b+c$.
+
+The time complexity is $O(n)$, where $n$ is the length of the array $nums$. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
 ```python
-
+class Solution:
+    def minimumCost(self, nums: List[int]) -> int:
+        a, b, c = nums[0], inf, inf
+        for x in nums[1:]:
+            if x < b:
+                c, b = b, x
+            elif x < c:
+                c = x
+        return a + b + c
 ```
 
 ```java
-
+class Solution {
+    public int minimumCost(int[] nums) {
+        int a = nums[0], b = 100, c = 100;
+        for (int i = 1; i < nums.length; ++i) {
+            if (nums[i] < b) {
+                c = b;
+                b = nums[i];
+            } else if (nums[i] < c) {
+                c = nums[i];
+            }
+        }
+        return a + b + c;
+    }
+}
 ```
 
 ```cpp
-
+class Solution {
+public:
+    int minimumCost(vector<int>& nums) {
+        int a = nums[0], b = 100, c = 100;
+        for (int i = 1; i < nums.size(); ++i) {
+            if (nums[i] < b) {
+                c = b;
+                b = nums[i];
+            } else if (nums[i] < c) {
+                c = nums[i];
+            }
+        }
+        return a + b + c;
+    }
+};
 ```
 
 ```go
+func minimumCost(nums []int) int {
+	a, b, c := nums[0], 100, 100
+	for _, x := range nums[1:] {
+		if x < b {
+			b, c = x, b
+		} else if x < c {
+			c = x
+		}
+	}
+	return a + b + c
+}
+```
 
+```ts
+function minimumCost(nums: number[]): number {
+    let [a, b, c] = [nums[0], 100, 100];
+    for (const x of nums.slice(1)) {
+        if (x < b) {
+            [b, c] = [x, b];
+        } else if (x < c) {
+            c = x;
+        }
+    }
+    return a + b + c;
+}
 ```
 
 <!-- tabs:end -->

solution/3000-3099/3010.Divide an Array Into Subarrays With Minimum Cost I/Solution.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int minimumCost(vector<int>& nums) {
+        int a = nums[0], b = 100, c = 100;
+        for (int i = 1; i < nums.size(); ++i) {
+            if (nums[i] < b) {
+                c = b;
+                b = nums[i];
+            } else if (nums[i] < c) {
+                c = nums[i];
+            }
+        }
+        return a + b + c;
+    }
+};

solution/3000-3099/3010.Divide an Array Into Subarrays With Minimum Cost I/Solution.go

@@ -0,0 +1,11 @@
+func minimumCost(nums []int) int {
+	a, b, c := nums[0], 100, 100
+	for _, x := range nums[1:] {
+		if x < b {
+			b, c = x, b
+		} else if x < c {
+			c = x
+		}
+	}
+	return a + b + c
+}

solution/3000-3099/3010.Divide an Array Into Subarrays With Minimum Cost I/Solution.java

@@ -0,0 +1,14 @@
+class Solution {
+    public int minimumCost(int[] nums) {
+        int a = nums[0], b = 100, c = 100;
+        for (int i = 1; i < nums.length; ++i) {
+            if (nums[i] < b) {
+                c = b;
+                b = nums[i];
+            } else if (nums[i] < c) {
+                c = nums[i];
+            }
+        }
+        return a + b + c;
+    }
+}

solution/3000-3099/3010.Divide an Array Into Subarrays With Minimum Cost I/Solution.py

@@ -0,0 +1,9 @@
+class Solution:
+    def minimumCost(self, nums: List[int]) -> int:
+        a, b, c = nums[0], inf, inf
+        for x in nums[1:]:
+            if x < b:
+                c, b = b, x
+            elif x < c:
+                c = x
+        return a + b + c

solution/3000-3099/3010.Divide an Array Into Subarrays With Minimum Cost I/Solution.ts

@@ -0,0 +1,11 @@
+function minimumCost(nums: number[]): number {
+    let [a, b, c] = [nums[0], 100, 100];
+    for (const x of nums.slice(1)) {
+        if (x < b) {
+            [b, c] = [x, b];
+        } else if (x < c) {
+            c = x;
+        }
+    }
+    return a + b + c;
+}