Simple C++ Solution. Beats 100%
IntuitionSince we need to make the array non-decreasing, combining adjacent elements with the smallest sum (often involving negative numbers or smaller values)
# Intuition
Since we need to make the array non-decreasing, combining adjacent elements with the smallest sum (often involving negative numbers or smaller values) will likely lead to the most efficient path toward a sorted array.

# Approach
Handle edge cases first: arrays of size 0 or 1 are already non-decreasing (I missed out on this when i first submitted the solution).

Use a while loop to repeatedly perform operations until the array becomes non-decreasing:
1. Check if the array is already non-decreasing (return if true)
2. Find the adjacent pair with minimum sum
3. Replace the pair with their sum (set first element to sum, remove second element)
4. After each operation, recheck if the array is non-decreasing
Continue until the array is sorted or only one element remains

# Complexity
- Time complexity:
O(n^2)

- Space complexity:
O(n)

# Code
```cpp []
class Solution {
public:
    int minimumPairRemoval(vector<int>& nums) {
        int operations = 0;

    if (nums.size() <= 1) {
        return 0;
    }
    
    while(nums.size() > 1){
        bool isNonDecreasing = true;
        for (int i = 1; i < nums.size(); i++) {
            if (nums[i] < nums[i-1]) {
                isNonDecreasing = false;
                break;
            }
        }

        if (isNonDecreasing) {
            return operations; // Already sorted
        }

        
        int minSum =nums[0] + nums[1];
        int minIndex = 0;
        for(int i = 1; i< nums.size() -1 ; i+=1){
            if(nums[i]+nums[i+1] < minSum){
                minSum = nums[i]+nums[i+1];
                minIndex = i;
            }
        }

        nums[minIndex] = minSum;
        nums.erase(nums.begin() + minIndex + 1);
        operations +=1;
    }

    return operations ;
    }
};
```
['C++']