feat: add solutions for lc No.3510 (#4971)

Author: yanglbme

solution/3500-3599/3510.Minimum Pair Removal to Sort Array II/README.md

@@ -82,32 +82,287 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：有序集合
+
+我们定义一个有序集合 $\textit{sl}$ 来存储所有相邻元素对的和及其左侧下标的元组 $(\textit{s}, i)$，定义另一个有序集合 $\textit{idx}$ 来存储当前数组中剩余元素的下标，并使用变量 $\textit{inv}$ 来记录当前数组中的逆序对数量。初始时，我们遍历数组 $\textit{nums}$，将所有相邻元素对的和及其左侧下标的元组加入有序集合 $\textit{sl}$ 中，并计算逆序对数量 $\textit{inv}$。
+
+在每次操作中，我们从有序集合 $\textit{sl}$ 中取出和最小的元素对 $(\textit{s}, i)$，那么我们可以得到下标 $i$ 和 $j$（其中 $j$ 是下标 $i$ 在有序集合 $\textit{idx}$ 中的下一个下标）对应的元素对是当前数组中和最小的相邻元素对。如果 $nums[i] > nums[j]$，则说明该元素对是一个逆序对，合并替换后逆序对数量 $\textit{inv}$ 减一。
+
+接下来，我们需要更新与下标 $i$ 和 $j$ 相关的元素对：
+
+1. 如果下标 $i$ 在有序集合 $\textit{idx}$ 中有前驱下标 $h$，则需要更新元素对 $(h, i)$。如果 $nums[h] > nums[i]$，则说明该元素对是一个逆序对，合并替换后逆序对数量 $\textit{inv}$ 减一。然后，我们从有序集合 $\textit{sl}$ 中移除元素对 $(h, i)$，并将新的元素对 $(h, s)$ 加入有序集合 $\textit{sl}$ 中。如果 $nums[h] > s$，则说明新的元素对是一个逆序对，合并替换后逆序对数量 $\textit{inv}$ 加一。
+
+2. 如果下标 $j$ 在有序集合 $\textit{idx}$ 中有后继下标 $k$，则需要更新元素对 $(j, k)$。如果 $nums[j] > nums[k]$，则说明该元素对是一个逆序对，合并替换后逆序对数量 $\textit{inv}$ 减一。然后，我们从有序集合 $\textit{sl}$ 中移除元素对 $(j, k)$，并将新的元素对 $(s, k)$ 加入有序集合 $\textit{sl}$ 中。如果 $s > nums[k]$，则说明新的元素对是一个逆序对，合并替换后逆序对数量 $\textit{inv}$ 加一。
+
+接下来，我们将下标 $i$ 处的元素替换为 $\textit{s}$，并从有序集合 $\textit{idx}$ 中移除下标 $j$。我们重复上述过程，直到逆序对数量 $\textit{inv}$ 为零为止。最终，操作次数即为将数组变为非递减所需的最小操作次数。
+
+时间复杂度 $O(n \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组的长度。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def minimumPairRemoval(self, nums: List[int]) -> int:
+        n = len(nums)
+        sl = SortedList()
+        idx = SortedList(range(n))
+        inv = 0
+        for i in range(n - 1):
+            sl.add((nums[i] + nums[i + 1], i))
+            if nums[i] > nums[i + 1]:
+                inv += 1
+        ans = 0
+        while inv:
+            ans += 1
+            s, i = sl.pop(0)
+            pos = idx.index(i)
+            j = idx[pos + 1]
+            if nums[i] > nums[j]:
+                inv -= 1
+            if pos > 0:
+                h = idx[pos - 1]
+                if nums[h] > nums[i]:
+                    inv -= 1
+                sl.remove((nums[h] + nums[i], h))
+                if nums[h] > s:
+                    inv += 1
+                sl.add((nums[h] + s, h))
+            if pos + 2 < len(idx):
+                k = idx[pos + 2]
+                if nums[j] > nums[k]:
+                    inv -= 1
+                sl.remove((nums[j] + nums[k], j))
+                if s > nums[k]:
+                    inv += 1
+                sl.add((s + nums[k], i))
+
+            nums[i] = s
+            idx.remove(j)
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    record Pair(long s, int i) implements Comparable<Pair> {
+        @Override
+        public int compareTo(Pair other) {
+            int compareS = Long.compare(this.s, other.s);
+            return compareS != 0 ? compareS : Integer.compare(this.i, other.i);
+        }
+    }
+
+    public int minimumPairRemoval(int[] nums) {
+        int n = nums.length;
+        int inv = 0;
+        TreeSet<Pair> sl = new TreeSet<>();
+        for (int i = 0; i < n - 1; ++i) {
+            if (nums[i] > nums[i + 1]) {
+                ++inv;
+            }
+            sl.add(new Pair(nums[i] + nums[i + 1], i));
+        }
+        TreeSet<Integer> idx = new TreeSet<>();
+        long[] arr = new long[n];
+        for (int i = 0; i < n; ++i) {
+            idx.add(i);
+            arr[i] = nums[i];
+        }
+
+        int ans = 0;
+        while (inv > 0) {
+            ++ans;
+            var p = sl.pollFirst();
+            long s = p.s;
+            int i = p.i;
+            int j = idx.higher(i);
+            if (arr[i] > arr[j]) {
+                --inv;
+            }
+            Integer h = idx.lower(i);
+            if (h != null) {
+                if (arr[h] > arr[i]) {
+                    --inv;
+                }
+                sl.remove(new Pair(arr[h] + arr[i], h));
+                if (arr[h] > s) {
+                    ++inv;
+                }
+                sl.add(new Pair(arr[h] + s, h));
+            }
+            Integer k = idx.higher(j);
+            if (k != null) {
+                if (arr[j] > arr[k]) {
+                    --inv;
+                }
+                sl.remove(new Pair(arr[j] + arr[k], j));
+                if (s > arr[k]) {
+                    ++inv;
+                }
+                sl.add(new Pair(s + arr[k], i));
+            }
+            arr[i] = s;
+            idx.remove(j);
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int minimumPairRemoval(vector<int>& nums) {
+        int n = nums.size();
+        int inv = 0;
+
+        set<pair<long long, int>> sl;
+        set<int> idx;
+        vector<long long> arr(nums.begin(), nums.end());
+
+        for (int i = 0; i < n; ++i) idx.insert(i);
+
+        for (int i = 0; i < n - 1; ++i) {
+            if (nums[i] > nums[i + 1]) {
+                ++inv;
+            }
+            sl.insert({(long long) nums[i] + nums[i + 1], i});
+        }
+
+        int ans = 0;
+        while (inv > 0) {
+            ++ans;
+
+            auto it = sl.begin();
+            long long s = it->first;
+            int i = it->second;
+            sl.erase(it);
+
+            auto j_it = idx.upper_bound(i);
+            int j = *j_it;
+
+            if (arr[i] > arr[j]) {
+                --inv;
+            }
+
+            auto i_it = idx.find(i);
+            if (i_it != idx.begin()) {
+                auto h_it = prev(i_it);
+                int h = *h_it;
+
+                if (arr[h] > arr[i]) {
+                    --inv;
+                }
+                sl.erase({arr[h] + arr[i], h});
+
+                if (arr[h] > s) {
+                    ++inv;
+                }
+                sl.insert({arr[h] + s, h});
+            }
+
+            auto k_it = next(j_it);
+            if (k_it != idx.end()) {
+                int k = *k_it;
+
+                if (arr[j] > arr[k]) {
+                    --inv;
+                }
+                sl.erase({arr[j] + arr[k], j});
+
+                if (s > arr[k]) {
+                    ++inv;
+                }
+                sl.insert({s + arr[k], i});
+            }
+
+            arr[i] = s;
+            idx.erase(j);
+        }
+
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
-
+func minimumPairRemoval(nums []int) (ans int) {
+	type pair struct{ s, i int }
+
+	n := len(nums)
+	inv := 0
+
+	sl := redblacktree.NewWith[pair, struct{}](func(a, b pair) int { return cmp.Or(a.s-b.s, a.i-b.i) })
+	idx := redblacktree.New[int, struct{}]()
+	for i := 0; i < n; i++ {
+		idx.Put(i, struct{}{})
+	}
+
+	for i := 0; i < n-1; i++ {
+		if nums[i] > nums[i+1] {
+			inv++
+		}
+		sl.Put(pair{nums[i] + nums[i+1], i}, struct{}{})
+	}
+
+	for inv > 0 {
+		ans++
+
+		it := sl.Iterator()
+		it.First()
+		p := it.Key()
+		sl.Remove(p)
+
+		s, i := p.s, p.i
+
+		jNode, _ := idx.Ceiling(i + 1)
+		j := jNode.Key
+
+		if nums[i] > nums[j] {
+			inv--
+		}
+
+		if hNode, ok := idx.Floor(i - 1); ok {
+			h := hNode.Key
+
+			if nums[h] > nums[i] {
+				inv--
+			}
+			sl.Remove(pair{nums[h] + nums[i], h})
+
+			if nums[h] > s {
+				inv++
+			}
+			sl.Put(pair{nums[h] + s, h}, struct{}{})
+		}
+
+		if kNode, ok := idx.Ceiling(j + 1); ok {
+			k := kNode.Key
+
+			if nums[j] > nums[k] {
+				inv--
+			}
+			sl.Remove(pair{nums[j] + nums[k], j})
+
+			if s > nums[k] {
+				inv++
+			}
+			sl.Put(pair{s + nums[k], i}, struct{}{})
+		}
+
+		nums[i] = s
+		idx.Remove(j)
+	}
+
+	return
+}
 ```
 
 <!-- tabs:end -->