Minimum Number of Increasing Subsequence to Be Removed

Minimum Number of Increasing Subsequence to Be Removed - Problem

You're given an array of integers, and your task is to completely empty it using a special operation: removing strictly increasing subsequences.

A strictly increasing subsequence is a sequence where each element is greater than the previous one. For example, in array [3, 1, 4, 1, 5], we could remove subsequence [1, 4, 5] or [3, 4, 5].

Goal: Find the minimum number of operations needed to make the array completely empty.

Key insight: This problem is equivalent to finding the length of the longest non-increasing subsequence, because elements in a non-increasing subsequence must be removed in separate operations.

Input & Output

example_1.py — Basic Case

$ Input: [1, 3, 6, 7, 9, 4, 10, 5, 6]

› Output: 3

💡 Note: We can remove three increasing subsequences: [1, 3, 6, 7, 9, 10], [4, 5, 6], and the array becomes empty. This is optimal because we need at least 3 operations due to the decreasing pattern 9→4→5.

example_2.py — Decreasing Array

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

› Output: 5

💡 Note: Since the array is strictly decreasing, no two elements can be in the same increasing subsequence. We need 5 operations, one for each element.

example_3.py — Increasing Array

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

› Output: 1

💡 Note: The entire array is already a strictly increasing subsequence, so we can remove all elements in a single operation.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Setup

You have books scattered on your desk: [3, 1, 4, 1, 5]

First Trip Strategy

Start with book 3, then realize you can't take book 1 (not increasing)

Optimal Planning

Use binary search to plan: find the best 'stack' for each book

Final Result

Minimum 2 trips needed: [1,4,5] and [3,1] or similar groupings

Key Takeaway

🎯 Key Insight: The minimum number of trips equals the length of the longest non-increasing subsequence, because those books can never be carried together in the same trip!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a greedy approach with binary search. The key insight is that this problem is equivalent to finding the length of the longest non-increasing subsequence. We maintain a 'tails' array and use binary search to efficiently place each element, achieving O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Binary Search (Optimal)	O(n log n)	O(n)	Use binary search to efficiently find where each element should go
Brute Force (Try All Combinations)	O(2^n)	O(n)	Generate all possible ways to partition the array into increasing subsequences

Greedy with Binary Search (Optimal) — Algorithm Steps

Initialize empty tails array to track smallest tail of each subsequence length
For each element in the array, use binary search to find the leftmost position where element can be placed
If position is at the end, we need a new subsequence (increment count)
Otherwise, update the tail at that position to current element

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize tails array

Start with empty array to track subsequence tails

Process each element

Use binary search to find where element should go

Place or extend

Either replace existing tail or extend with new subsequence

Count subsequences

Final tails array length is the answer

Code -

solution.c — C

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

int binarySearch(int* arr, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = (left + right) / 2;
        if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int minimumOperations(int* nums, int n) {
    int* tails = (int*)malloc(n * sizeof(int));
    int tailsSize = 0;
    
    for (int i = 0; i < n; i++) {
        int pos = binarySearch(tails, tailsSize, nums[i]);
        
        if (pos == tailsSize) {
            tails[tailsSize++] = nums[i];
        } else {
            tails[pos] = nums[i];
        }
    }
    
    int result = tailsSize;
    free(tails);
    return result;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[100];
    int n = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", minimumOperations(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

For each of n elements, we perform binary search which takes O(log n)

⚡ Linearithmic

Space Complexity

O(n)

In worst case, tails array can have n elements

⚡ Linearithmic Space

68.2K Views

High Frequency

~25 min Avg. Time

1.8K 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

Greedy with Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler