chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Hard/2026-01-23-3510-Minimum-Pair-Removal-to-Sort-Array-II/explanation.md

@@ -0,0 +1,36 @@
+# Minimum Pair Removal to Sort Array II (Hard)
+
+**Problem ID:** 3510  
+**Date:** 2026-01-23  
+**Link:** https://leetcode.com/problems/minimum-pair-removal-to-sort-array-ii/
+
+## Approach
+
+To solve the problem of determining the minimum number of operations needed to make an array non-decreasing via adjacent pair removal, we can follow these steps:
+
+### Problem Understanding
+The goal is to repeatedly replace adjacent pairs with their sum until the array is non-decreasing. The key challenge is to select the pair with the minimum sum efficiently and ensure that the resultant array is sorted.
+
+### Approach
+1. **Identify Non-Decreasing Pairs**: First, we need to identify pairs in the array that, when summed, will not disrupt the non-decreasing order. If a pair (nums[i], nums[i+1]) is such that nums[i] > nums[i+1], we need to consider replacing it.
+
+2. **Priority Queue**: Use a min-heap (priority queue) to efficiently track pairs based on their sums. This allows us to always access the pair with the minimum sum quickly. The heap will store pairs along with their indices for easy retrieval.
+
+3. **Operation Simulation**: 
+   - While the heap is not empty, extract the pair with the minimum sum.
+   - Replace the extracted pair in the array with their sum.
+   - After the replacement, check the new adjacent pairs to see if they now form a valid pair that can be summed in future operations.
+   - Increment the operation count each time a replacement is made.
+
+4. **Termination**: The process continues until no more pairs need to be replaced to achieve a non-decreasing order.
+
+### Data Structures
+- **Min-Heap**: To maintain pairs and their sums efficiently.
+- **Array**: To hold the current state of the numbers as we perform operations.
+
+### Complexity
+- **Time Complexity**: The overall complexity is O(n log n) due to the heap operations, where n is the length of the input array. Each operation involves inserting and removing elements from the heap.
+- **Space Complexity**: O(n) for storing the heap and potentially the modified array.
+
+### Conclusion
+This approach effectively reduces the problem to a series of controlled operations based on the properties of the array and the sums of adjacent pairs, leveraging a priority queue for efficiency. By focusing on the minimum sum pairs, we ensure that each operation is optimal toward achieving a non-decreasing order in the least number of steps.

Hard/2026-01-23-3510-Minimum-Pair-Removal-to-Sort-Array-II/solution.java

@@ -0,0 +1,37 @@
+class Solution {
+    public int minimumOperations(int[] nums) {
+        int n = nums.length;
+        int operations = 0;
+
+        while (!isNonDecreasing(nums)) {
+            int minSum = Integer.MAX_VALUE;
+            int minIndex = -1;
+
+            for (int i = 0; i < n - 1; i++) {
+                int sum = nums[i] + nums[i + 1];
+                if (sum < minSum) {
+                    minSum = sum;
+                    minIndex = i;
+                }
+            }
+
+            nums[minIndex] = nums[minIndex] + nums[minIndex + 1];
+            for (int i = minIndex + 1; i < n - 1; i++) {
+                nums[i] = nums[i + 1];
+            }
+            n--;
+            operations++;
+        }
+
+        return operations;
+    }
+
+    private boolean isNonDecreasing(int[] nums) {
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] < nums[i - 1]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

Hard/2026-01-23-3510-Minimum-Pair-Removal-to-Sort-Array-II/solution.js

@@ -0,0 +1,34 @@
+var minimumOperations = function(nums) {
+    let operations = 0;
+    let n = nums.length;
+
+    while (true) {
+        let minSum = Infinity;
+        let minIndex = -1;
+
+        for (let i = 0; i < n - 1; i++) {
+            if (nums[i] + nums[i + 1] < minSum) {
+                minSum = nums[i] + nums[i + 1];
+                minIndex = i;
+            }
+        }
+
+        if (minIndex === -1) break;
+
+        let newValue = nums[minIndex] + nums[minIndex + 1];
+        nums[minIndex] = newValue;
+        nums.splice(minIndex + 1, 1);
+        operations++;
+
+        if (isSorted(nums)) break;
+    }
+
+    return operations;
+};
+
+function isSorted(arr) {
+    for (let i = 1; i < arr.length; i++) {
+        if (arr[i] < arr[i - 1]) return false;
+    }
+    return true;
+}

Hard/2026-01-23-3510-Minimum-Pair-Removal-to-Sort-Array-II/solution.py

@@ -0,0 +1,20 @@
+class Solution:
+    def minimumOperations(self, nums: List[int]) -> int:
+        operations = 0
+        while True:
+            min_sum = float('inf')
+            min_index = -1
+            
+            for i in range(len(nums) - 1):
+                if nums[i] + nums[i + 1] < min_sum:
+                    min_sum = nums[i] + nums[i + 1]
+                    min_index = i
+            
+            if min_index == -1 or (min_index > 0 and nums[min_index - 1] > nums[min_index] + nums[min_index + 1]) or (min_index < len(nums) - 2 and nums[min_index] + nums[min_index + 1] > nums[min_index + 2]):
+                break
+            
+            nums[min_index] = nums[min_index] + nums[min_index + 1]
+            del nums[min_index + 1]
+            operations += 1
+        
+        return operations

README.md

@@ -342,3 +342,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-01-20 — [Construct the Minimum Bitwise Array I](https://leetcode.com/problems/construct-the-minimum-bitwise-array-i/) (Easy) → `Easy/2026-01-20-3314-Construct-the-Minimum-Bitwise-Array-I`
 - 2026-01-21 — [Construct the Minimum Bitwise Array II](https://leetcode.com/problems/construct-the-minimum-bitwise-array-ii/) (Medium) → `Medium/2026-01-21-3315-Construct-the-Minimum-Bitwise-Array-II`
 - 2026-01-22 — [Minimum Pair Removal to Sort Array I](https://leetcode.com/problems/minimum-pair-removal-to-sort-array-i/) (Easy) → `Easy/2026-01-22-3507-Minimum-Pair-Removal-to-Sort-Array-I`
+- 2026-01-23 — [Minimum Pair Removal to Sort Array II](https://leetcode.com/problems/minimum-pair-removal-to-sort-array-ii/) (Hard) → `Hard/2026-01-23-3510-Minimum-Pair-Removal-to-Sort-Array-II`