Minimum Pair Removal to Sort Array II - Practice Coding Problems

Minimum Pair Removal to Sort Array II - Problem

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

Transform Array to Non-Decreasing with Strategic Pair Merging

You're given an array nums and need to make it non-decreasing (sorted) using a special operation. In each operation, you must:

1. Find all adjacent pairs with the minimum sum
2. If multiple such pairs exist, choose the leftmost one
3. Replace that pair with their sum

Your goal is to find the minimum number of operations needed to make the array non-decreasing.

Example: [3, 2, 1, 4]
• Operation 1: Pairs are (3,2)=5, (2,1)=3, (1,4)=5. Min is 3, so merge (2,1) → [3, 3, 4]
• Result: 1 operation (array is now sorted)

The challenge lies in choosing the optimal sequence of merges to minimize total operations.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: Initial array: [3, 2, 1, 4]. Adjacent pairs and their sums: (3,2)→5, (2,1)→3, (1,4)→5. The minimum sum is 3 from pair (2,1), so we merge them: [3, 3, 4]. Now the array is non-decreasing, so we needed 1 operation.

example_2.py — Multiple Operations

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

› Output: 3

💡 Note: Step 1: [4,3,2,1] → pairs (4,3)→7, (3,2)→5, (2,1)→3. Min is 3, merge (2,1) → [4,3,3]. Step 2: [4,3,3] → pairs (4,3)→7, (3,3)→6. Min is 6, merge (3,3) → [4,6]. Step 3: [4,6] → pair (4,6)→10. Min is 10, merge (4,6) → [10]. Total: 3 operations.

example_3.py — Already Sorted

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

› Output: 0

💡 Note: The array [1, 2, 3, 4] is already non-decreasing (1 ≤ 2 ≤ 3 ≤ 4), so no operations are needed.

Visualization

Tap to expand

Understanding the Visualization

Find All Adjacent Pairs

Calculate sum for each adjacent pair: (3,2)=5, (2,1)=3, (1,4)=5

Choose Minimum Sum

Minimum sum is 3 from pair (2,1). Since it's unique, select this pair

Merge the Pair

Replace (2,1) with their sum 3, resulting in array [3,3,4]

Check if Sorted

Array [3,3,4] is non-decreasing (3≤3≤4), so we're done in 1 operation

Key Takeaway

🎯 Key Insight: The optimal approach uses a priority queue to efficiently track minimum pairs and a doubly-linked list for fast merging, avoiding the need to rescan unchanged portions of the array.

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

In worst case O(n) operations, each involving O(log n) heap operations and O(n) pairs to track

⚠ Quadratic Growth

Space Complexity

O(n)

Space for priority queue, doubly-linked list, and tracking structures

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁶
You must always choose the leftmost minimum pair when there are ties
Array elements can become very large after multiple merge operations

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

This problem requires simulating the merge process efficiently. The brute force approach repeatedly scans the array, while the optimal solution uses a priority queue to track minimum adjacent pairs and a doubly-linked list for O(1) merging. Key insight: only update neighboring pairs affected by each merge, avoiding redundant work.

Common Approaches

Approach	Time	Space	Notes
✓ Priority Queue + Doubly Linked List (Optimal)	O(n² log n)	O(n)	Use priority queue to track minimum pairs and doubly linked list for efficient merging
Brute Force Simulation	O(n³)	O(1)	Repeatedly scan entire array to find minimum adjacent pair and merge

Priority Queue + Doubly Linked List (Optimal) — Algorithm Steps

Build doubly-linked list representation of array
Initialize priority queue with all adjacent pairs
While array not sorted, extract minimum valid pair from queue
Merge the pair and update affected neighboring pairs
Add new pairs formed after merge to priority queue

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Structures

Create doubly-linked list and populate priority queue with all adjacent pairs

Extract Minimum

Get the minimum valid pair from priority queue

Merge and Update

Merge the pair and update affected neighboring relationships

Add New Pairs

Insert newly formed adjacent pairs into priority queue

Code -

solution.c — C

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

typedef struct ListNode {
    int val;
    int id;
    struct ListNode* prev;
    struct ListNode* next;
} ListNode;

typedef struct {
    int sum;
    int leftId;
    int rightId;
} Pair;

typedef struct {
    Pair* data;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = malloc(sizeof(MinHeap));
    heap->data = malloc(capacity * sizeof(Pair));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void swap(Pair* a, Pair* b) {
    Pair temp = *a;
    *a = *b;
    *b = temp;
}

void heapifyUp(MinHeap* heap, int index) {
    while (index > 0) {
        int parent = (index - 1) / 2;
        if (heap->data[parent].sum <= heap->data[index].sum) break;
        swap(&heap->data[parent], &heap->data[index]);
        index = parent;
    }
}

void heapifyDown(MinHeap* heap, int index) {
    while (2 * index + 1 < heap->size) {
        int minIndex = 2 * index + 1;
        if (2 * index + 2 < heap->size && heap->data[2 * index + 2].sum < heap->data[minIndex].sum) {
            minIndex = 2 * index + 2;
        }
        if (heap->data[index].sum <= heap->data[minIndex].sum) break;
        swap(&heap->data[index], &heap->data[minIndex]);
        index = minIndex;
    }
}

void push(MinHeap* heap, Pair pair) {
    if (heap->size >= heap->capacity) return;
    heap->data[heap->size] = pair;
    heapifyUp(heap, heap->size);
    heap->size++;
}

Pair pop(MinHeap* heap) {
    Pair min = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    if (heap->size > 0) heapifyDown(heap, 0);
    return min;
}

int isNonDecreasing(ListNode* head) {
    ListNode* current = head;
    while (current && current->next) {
        if (current->val > current->next->val) return 0;
        current = current->next;
    }
    return 1;
}

int minimumOperations(int* nums, int numsSize) {
    if (numsSize <= 1) return 0;
    
    // Create linked list
    ListNode* nodes = malloc(numsSize * sizeof(ListNode));
    for (int i = 0; i < numsSize; i++) {
        nodes[i].val = nums[i];
        nodes[i].id = i;
        nodes[i].prev = NULL;
        nodes[i].next = NULL;
    }
    
    for (int i = 0; i < numsSize - 1; i++) {
        nodes[i].next = &nodes[i + 1];
        nodes[i + 1].prev = &nodes[i];
    }
    
    ListNode* head = &nodes[0];
    MinHeap* pq = createHeap(numsSize * numsSize);
    
    // Simple array-based tracking (for demonstration)
    int pairCount = 0;
    Pair validPairs[1000];
    
    // Add initial pairs
    ListNode* current = head;
    while (current && current->next) {
        Pair p = {current->val + current->next->val, current->id, current->next->id};
        push(pq, p);
        validPairs[pairCount++] = p;
        current = current->next;
    }
    
    int operations = 0;
    
    while (!isNonDecreasing(head) && pq->size > 0) {
        Pair minPair = pop(pq);
        
        // Find corresponding nodes
        ListNode* leftNode = NULL;
        ListNode* rightNode = NULL;
        
        for (int i = 0; i < numsSize; i++) {
            if (nodes[i].id == minPair.leftId) leftNode = &nodes[i];
            if (nodes[i].id == minPair.rightId) rightNode = &nodes[i];
        }
        
        if (!leftNode || !rightNode || leftNode->next != rightNode) continue;
        
        // Merge
        leftNode->val = minPair.sum;
        leftNode->next = rightNode->next;
        if (rightNode->next) {
            rightNode->next->prev = leftNode;
        }
        
        // Mark rightNode as removed
        rightNode->id = -1;
        
        // Add new pairs
        if (leftNode->prev) {
            Pair newPair = {leftNode->prev->val + leftNode->val, leftNode->prev->id, leftNode->id};
            push(pq, newPair);
        }
        if (leftNode->next) {
            Pair newPair = {leftNode->val + leftNode->next->val, leftNode->id, leftNode->next->id};
            push(pq, newPair);
        }
        
        operations++;
    }
    
    free(pq->data);
    free(pq);
    free(nodes);
    
    return operations;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

In worst case O(n) operations, each involving O(log n) heap operations and O(n) pairs to track

⚠ Quadratic Growth

Space Complexity

O(n)

Space for priority queue, doubly-linked list, and tracking structures

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁶
You must always choose the leftmost minimum pair when there are ties
Array elements can become very large after multiple merge operations

26.1K Views

Medium Frequency

~35 min Avg. Time

847 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Priority Queue + Doubly Linked List (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler