Minimum Pair Removal to Sort Array I

Minimum Pair Removal to Sort Array I - Problem

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

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 Unsorted Array

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

› Output: 3

💡 Note: First merge (2,1)→3 giving [3,4,3], then merge (3,4)→7 giving [7,3], finally merge (7,3)→10 giving [10] (sorted). Total: 3 operations.

Example 2 — Already Sorted

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

› Output: 0

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

Example 3 — Single Element

$ Input: nums = [5]

› Output: 0

💡 Note: Single element array is trivially non-decreasing, no operations needed.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15

The key insight is to repeatedly find and merge the adjacent pair with minimum sum until the array becomes non-decreasing. The brute force approach scans all pairs in each iteration, while the optimized approach uses efficient data structures and early termination. Time: O(n²), Space: O(1).

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, and repeat until the array becomes non-decreasing.

Optimized Simulation

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

Use optimized data structures to track adjacent pairs and implement early termination when array becomes sorted. Avoid unnecessary heap operations when possible.

Priority Queue Optimization

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

Maintain a priority queue of all adjacent pairs sorted by sum. When we merge a pair, update affected neighboring pairs in the heap.

Brute Force Simulation — Algorithm Steps

Step 1: Check if array is already non-decreasing
Step 2: Find adjacent pair with minimum sum (leftmost if tie)
Step 3: Replace pair with their sum
Step 4: Repeat until sorted

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with unsorted array [3,4,2,1]

Find Min Pair

Scan all adjacent pairs: (3,4)=7, (4,2)=6, (2,1)=3. Min is (2,1)=3

Merge and Repeat

Replace [2,1] with [3], continue until sorted

Code -

solution.c — C

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

int solution(int* nums, int size) {
    int operations = 0;
    
    while (size > 1) {
        // Check if array is non-decreasing
        int isSorted = 1;
        for (int i = 1; i < size; i++) {
            if (nums[i] < nums[i-1]) {
                isSorted = 0;
                break;
            }
        }
        
        if (isSorted) break;
        
        // Find minimum adjacent pair sum (leftmost if tie)
        int minSum = INT_MAX;
        int minIdx = -1;
        
        for (int i = 0; i < size - 1; i++) {
            int pairSum = nums[i] + nums[i+1];
            if (pairSum < minSum) {
                minSum = pairSum;
                minIdx = i;
            }
        }
        
        // Merge the pair
        nums[minIdx] = minSum;
        for (int i = minIdx + 1; i < size - 1; i++) {
            nums[i] = nums[i + 1];
        }
        size--;
        operations++;
    }
    
    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;
    
    // Simple parsing
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Each operation scans O(n) pairs, up to O(n) operations, each taking O(n) time to rebuild array

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses constant extra space for variables

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~15 min Avg. Time

892 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