feat: add solutions for lc No.3507 (#4969)

Author: yanglbme

solution/2900-2999/2943.Maximize Area of Square Hole in Grid/README.md

@@ -119,13 +119,13 @@ tags:
 
 题目实际上要我们找出数组中最长的连续递增子序列的长度，然后再加上 $1$。
 
-我们定义一个函数 $f(nums)$，表示数组 $nums$ 中最长的连续递增子序列的长度。
+我们定义一个函数 $f(\textit{nums})$，表示数组 $\textit{nums}$ 中最长的连续递增子序列的长度。
 
-对于数组 $nums$，我们先对其进行排序，然后遍历数组，如果当前元素 $nums[i]$ 等于前一个元素 $nums[i - 1]$ 加 $1$，则说明当前元素可以加入到连续递增子序列中，否则，说明当前元素不能加入到连续递增子序列中，我们需要重新开始计算连续递增子序列的长度。最后，我们返回连续递增子序列的长度加 $1$。
+对于数组 $\textit{nums}$，我们先对其进行排序，然后遍历数组，如果当前元素 $\textit{nums}[i]$ 等于前一个元素 $\textit{nums}[i - 1]$ 加 $1$，则说明当前元素可以加入到连续递增子序列中，否则，说明当前元素不能加入到连续递增子序列中，我们需要重新开始计算连续递增子序列的长度。最后，我们返回连续递增子序列的长度加 $1$。
 
-我们在求出 $hBars$ 和 $vBars$ 中最长的连续递增子序列的长度之后，我们取两者中的最小值作为正方形的边长，然后再求出正方形的面积即可。
+我们在求出 $\textit{hBars}$ 和 $\textit{vBars}$ 中最长的连续递增子序列的长度之后，我们取两者中的最小值作为正方形的边长，然后再求出正方形的面积即可。
 
-时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $hBars$ 或 $vBars$ 的长度。
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $\textit{hBars}$ 或 $\textit{vBars}$ 的长度。
 
 <!-- tabs:start -->
 

solution/2900-2999/2943.Maximize Area of Square Hole in Grid/README_EN.md

@@ -92,15 +92,15 @@ tags:
 
 ### Solution 1: Sorting
 
-The problem essentially asks us to find the length of the longest consecutive increasing subsequence in the array, and then add 1 to it.
+The problem essentially asks us to find the length of the longest consecutive increasing subsequence in the array, and then add $1$.
 
-We define a function $f(nums)$, which represents the length of the longest consecutive increasing subsequence in the array $nums$.
+We define a function $f(\textit{nums})$ to represent the length of the longest consecutive increasing subsequence in the array $\textit{nums}$.
 
-For the array $nums$, we first sort it, then traverse the array. If the current element $nums[i]$ equals the previous element $nums[i - 1]$ plus 1, it means that the current element can be added to the consecutive increasing subsequence. Otherwise, it means that the current element cannot be added to the consecutive increasing subsequence, and we need to start calculating the length of the consecutive increasing subsequence again. Finally, we return the length of the consecutive increasing subsequence plus 1.
+For the array $\textit{nums}$, we first sort it, then iterate through the array. If the current element $\textit{nums}[i]$ equals the previous element $\textit{nums}[i - 1]$ plus $1$, it means the current element can be added to the consecutive increasing subsequence. Otherwise, the current element cannot be added to the consecutive increasing subsequence, and we need to restart counting the length of the consecutive increasing subsequence. Finally, we return the length of the consecutive increasing subsequence plus $1$.
 
-After finding the length of the longest consecutive increasing subsequence in $hBars$ and $vBars$, we take the minimum of the two as the side length of the square, and then calculate the area of the square.
+After finding the lengths of the longest consecutive increasing subsequences in $\textit{hBars}$ and $\textit{vBars}$, we take the minimum of the two as the side length of the square, and then calculate the area of the square.
 
-The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array $hBars$ or $vBars$.
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$, where $n$ is the length of the array $\textit{hBars}$ or $\textit{vBars}$.
 
 <!-- tabs:start -->
 

solution/3500-3599/3507.Minimum Pair Removal to Sort Array I/README.md

@@ -81,32 +81,228 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：模拟
+
+我们定义一个函数 $\text{is\_non\_decreasing}(a)$，用于判断数组 $a$ 是否为非递减数组。
+
+我们使用一个循环，直到数组 $arr$ 为非递减数组为止。在每次循环中，我们找到数组 $arr$ 中相邻元素对的和的最小值，并记录该对的左边元素的下标 $k$。然后，我们将该对的和替换左边的元素，并删除右边的元素。最后，我们返回操作的次数。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n)$。其中 $n$ 为数组的长度。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def minimumPairRemoval(self, nums: List[int]) -> int:
+        arr = nums[:]
+        ans = 0
+
+        def is_non_decreasing(a: List[int]) -> bool:
+            for i in range(1, len(a)):
+                if a[i] < a[i - 1]:
+                    return False
+            return True
+
+        while not is_non_decreasing(arr):
+            k = 0
+            s = arr[0] + arr[1]
+            for i in range(1, len(arr) - 1):
+                t = arr[i] + arr[i + 1]
+                if s > t:
+                    s = t
+                    k = i
+            arr[k] = s
+            arr.pop(k + 1)
+            ans += 1
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int minimumPairRemoval(int[] nums) {
+        List<Integer> arr = new ArrayList<>();
+        for (int x : nums) {
+            arr.add(x);
+        }
+        int ans = 0;
+        while (!isNonDecreasing(arr)) {
+            int k = 0;
+            int s = arr.get(0) + arr.get(1);
+            for (int i = 1; i < arr.size() - 1; ++i) {
+                int t = arr.get(i) + arr.get(i + 1);
+                if (s > t) {
+                    s = t;
+                    k = i;
+                }
+            }
+            arr.set(k, s);
+            arr.remove(k + 1);
+            ++ans;
+        }
+        return ans;
+    }
+
+    private boolean isNonDecreasing(List<Integer> arr) {
+        for (int i = 1; i < arr.size(); ++i) {
+            if (arr.get(i) < arr.get(i - 1)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int minimumPairRemoval(vector<int>& nums) {
+        vector<int> arr = nums;
+        int ans = 0;
+
+        while (!isNonDecreasing(arr)) {
+            int k = 0;
+            int s = arr[0] + arr[1];
+
+            for (int i = 1; i < arr.size() - 1; ++i) {
+                int t = arr[i] + arr[i + 1];
+                if (s > t) {
+                    s = t;
+                    k = i;
+                }
+            }
+
+            arr[k] = s;
+            arr.erase(arr.begin() + (k + 1));
+            ++ans;
+        }
+
+        return ans;
+    }
+
+private:
+    bool isNonDecreasing(const vector<int>& arr) {
+        for (int i = 1; i < (int) arr.size(); ++i) {
+            if (arr[i] < arr[i - 1]) {
+                return false;
+            }
+        }
+        return true;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func minimumPairRemoval(nums []int) int {
+	arr := append([]int(nil), nums...)
+	ans := 0
+
+	isNonDecreasing := func(a []int) bool {
+		for i := 1; i < len(a); i++ {
+			if a[i] < a[i-1] {
+				return false
+			}
+		}
+		return true
+	}
+
+	for !isNonDecreasing(arr) {
+		k := 0
+		s := arr[0] + arr[1]
+
+		for i := 1; i < len(arr)-1; i++ {
+			t := arr[i] + arr[i+1]
+			if s > t {
+				s = t
+				k = i
+			}
+		}
+
+		arr[k] = s
+		copy(arr[k+1:], arr[k+2:])
+		arr = arr[:len(arr)-1]
+		ans++
+	}
+
+	return ans
+}
+```
+
+#### TypeScript
+
+```ts
+function minimumPairRemoval(nums: number[]): number {
+    const arr = nums.slice();
+    let ans = 0;
+    const isNonDecreasing = (a: number[]): boolean => {
+        for (let i = 1; i < a.length; i++) {
+            if (a[i] < a[i - 1]) {
+                return false;
+            }
+        }
+        return true;
+    };
+    while (!isNonDecreasing(arr)) {
+        let k = 0;
+        let s = arr[0] + arr[1];
+        for (let i = 1; i < arr.length - 1; ++i) {
+            const t = arr[i] + arr[i + 1];
+            if (s > t) {
+                s = t;
+                k = i;
+            }
+        }
+        arr[k] = s;
+        arr.splice(k + 1, 1);
+        ans++;
+    }
+    return ans;
+}
+```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn minimum_pair_removal(nums: Vec<i32>) -> i32 {
+        let mut arr: Vec<i32> = nums.clone();
+        let mut ans: i32 = 0;
+
+        fn is_non_decreasing(a: &Vec<i32>) -> bool {
+            for i in 1..a.len() {
+                if a[i] < a[i - 1] {
+                    return false;
+                }
+            }
+            true
+        }
+
+        while !is_non_decreasing(&arr) {
+            let mut k: usize = 0;
+            let mut s: i32 = arr[0] + arr[1];
+            for i in 1..arr.len() - 1 {
+                let t: i32 = arr[i] + arr[i + 1];
+                if s > t {
+                    s = t;
+                    k = i;
+                }
+            }
+            arr[k] = s;
+            arr.remove(k + 1);
+            ans += 1;
+        }
+
+        ans
+    }
+}
 ```
 
 <!-- tabs:end -->