Minimum Pair Removal to Sort Array II

Minimum Pair Removal to Sort Array II - Problem

Array Hash Table Linked List Heap (Priority Queue) Simulation Doubly-Linked List Ordered Set Hard

Given an array nums, you can perform the following operation any number of times:

Select the adjacent pair with the minimum sum in nums.
If multiple such pairs exist, choose the leftmost one.
Replace the pair with their sum.

Return the minimum number of operations needed to make the array non-decreasing.

An array is said to be non-decreasing if each element is greater than or equal to its previous element (if it exists).

Input & Output

Example 1 — Basic Case

$ Input: nums = [4,2,1,3,5]

› Output: 4

💡 Note: Step 1: Min pair is (2,1) with sum 3 → [4,3,3,5]. Step 2: Min pair is (3,3) with sum 6 → [4,6,5]. Step 3: Min pair is (4,6) with sum 10 → [10,5]. Step 4: Only pair (10,5) with sum 15 → [15]. Total: 4 operations.

Example 2 — Already Sorted

$ Input: nums = [1,2,3,4,5]

› Output: 0

💡 Note: Array is already non-decreasing (1 ≤ 2 ≤ 3 ≤ 4 ≤ 5), so no operations needed.

Example 3 — Reverse Order

$ Input: nums = [5,4,3,2,1]

› Output: 4

💡 Note: Always merge smallest adjacent sum: (2,1)→3: [5,4,3,3]. Then (3,3)→6: [5,4,6]. Then (4,6)→10: [5,10]. Then (5,10)→15: [15]. Total: 4 operations.

Constraints

1 ≤ nums.length ≤ 10³
-10⁶ ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 A Amazon 12 M Microsoft 8

The key insight is to repeatedly find and merge the adjacent pair with minimum sum until the array becomes non-decreasing. The optimal approach uses efficient simulation with O(n²) time complexity by scanning for minimum pairs in each iteration.

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(n³) Space: O(1)

In each iteration, scan the entire array to find the adjacent pair with minimum sum, merge it, then repeat until array is non-decreasing. This simulates the exact process described in the problem.

Priority Queue Optimization

⏱️ Time: O(n² log n) Space: O(n)

Maintain a priority queue of all adjacent pairs with their sums and positions. Always process the minimum sum pair first, updating affected pairs when merging occurs. This avoids rescanning the entire array each time.

Simulation with Tracking

⏱️ Time: O(n²) Space: O(1)

Improve the basic simulation by tracking the current minimum pair during each scan, avoiding redundant comparisons. Also add early termination when array becomes non-decreasing and optimize pair finding logic.

Brute Force Simulation — Algorithm Steps

Scan array to find adjacent pair with minimum sum
If multiple pairs have same sum, choose leftmost
Replace pair with their sum
Repeat until array is non-decreasing

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Min Pair

Scan all adjacent pairs to find minimum sum

Merge Pair

Replace the pair with their sum

Repeat

Continue until array is non-decreasing

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

int solution(int* nums, int numsSize) {
    int* arr = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        arr[i] = nums[i];
    }
    
    int size = numsSize;
    int operations = 0;
    
    while (1) {
        if (size <= 1) break;
        
        // Check if already non-decreasing
        int isSorted = 1;
        for (int i = 1; i < size; i++) {
            if (arr[i] < arr[i-1]) {
                isSorted = 0;
                break;
            }
        }
        
        if (isSorted) break;
        
        // Find minimum sum pair (leftmost if tie)
        long long minSum = LLONG_MAX;
        int minIdx = -1;
        
        for (int i = 0; i < size - 1; i++) {
            long long pairSum = (long long)arr[i] + arr[i+1];
            if (pairSum < minSum) {
                minSum = pairSum;
                minIdx = i;
            }
        }
        
        // Merge the pair
        arr[minIdx] = (int)minSum;
        for (int i = minIdx + 1; i < size - 1; i++) {
            arr[i] = arr[i + 1];
        }
        size--;
        operations++;
    }
    
    free(arr);
    return operations;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int size = 0;
    
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9' || token[0] == '-') {
            nums[size++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", solution(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Each operation scans O(n) pairs, up to O(n) operations, and each merge takes O(n) to shift elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses constant extra variables for tracking minimum pair

⚡ Linearithmic Space

8.5K Views

Medium Frequency

~35 min Avg. Time

245 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler