Minimum Operations to Make a Subsequence - Practice Coding Problems

Minimum Operations to Make a Subsequence - Problem

You're tasked with transforming an array to make a specific sequence appear as a subsequence. Given a target array of distinct integers and an arr array that may contain duplicates, you need to find the minimum number of insertion operations required.

In each operation, you can insert any integer at any position in arr. For example, if arr = [1,4,1,2], you can insert 3 to get [1,4,3,1,2].

Goal: Return the minimum operations needed to make target a subsequence of the modified arr.

Note: A subsequence maintains the relative order of elements but allows deletions. For example, [2,7,4] is a subsequence of [4,2,3,7,2,1,4], but [2,4,2] is not.

Input & Output

example_1.py — Basic Example

$ Input: target = [5,1,3], arr = [9,4,2,3,4]

› Output: 2

💡 Note: We need to insert 5 and 1 to make [5,1,3] a subsequence. Only 3 already exists in arr in the correct position.

example_2.py — All Elements Present

$ Input: target = [6,4,8,1,3], arr = [4,7,6,2,3,4,6,1,8]

› Output: 3

💡 Note: The longest subsequence we can form from existing elements is [6,4,8] or [4,1,3] (length 3). So we need to insert 5-3=2 elements... Wait, let me recalculate: we can form [6,1,3] or [4,8,3] giving us length 3, so we need 5-3=2 insertions.

example_3.py — No Common Elements

$ Input: target = [5,1,3], arr = [9,4,2,7,6]

› Output: 3

💡 Note: No elements from target exist in arr, so we need to insert all 3 elements from target.

Visualization

Tap to expand

Understanding the Visualization

Create ingredient map

Map each recipe ingredient to its required position

Check pantry

Go through pantry and note positions of recipe ingredients we have

Find best sequence

Find longest increasing sequence of positions (ingredients in correct order)

Calculate shopping list

Ingredients to buy = Total needed - Longest sequence we have

Key Takeaway

🎯 Key Insight: The minimum insertions needed equals the total target length minus the length of the longest subsequence we can already form in the correct order - efficiently found using the Longest Increasing Subsequence algorithm!

Time & Space Complexity

Time Complexity

⏱️

O(n²×m)

For each of n target elements, we try m arr elements, with recursive depth of n

⚠ Quadratic Growth

Space Complexity

O(n×m)

Memoization table size plus recursion stack depth

⚡ Linearithmic Space

Constraints

1 ≤ target.length, arr.length ≤ 10⁵
1 ≤ target[i], arr[i] ≤ 10⁹
target contains distinct integers
arr can contain duplicate integers

Asked in

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

The optimal solution uses a clever transformation: map the problem to finding the Longest Increasing Subsequence (LIS). Since target has distinct elements, we can map each target element to its index, then transform arr accordingly. The minimum insertions needed equals target.length - LIS_length, achievable in O(n log n) time using binary search.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recursive with Memoization)	O(n²×m)	O(n×m)	Try all possible ways to match target elements with arr elements recursively
Hash Map + Longest Increasing Subsequence (Optimal)	O(n log n)	O(n)	Convert problem to finding LIS using coordinate compression and binary search

Brute Force (Recursive with Memoization) — Algorithm Steps

Start with first element of target and position 0 in arr
For each target element, try matching with every valid element in arr
Recursively solve for remaining target elements
Take minimum operations across all choices
Use memoization to avoid recomputing same subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

Start matching

Begin with first target element and first arr position

Make decision

For each position, decide to match or skip

Recurse

Continue with remaining elements

Backtrack

Try alternative choices and take minimum

Code -

solution.c — C

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

#define MAX_SIZE 1000
int memo[MAX_SIZE][MAX_SIZE];
int target[MAX_SIZE], arr[MAX_SIZE];
int targetSize, arrSize;

int dfs(int targetIdx, int arrIdx) {
    if (targetIdx == targetSize) return 0;
    if (arrIdx == arrSize) return targetSize - targetIdx;
    if (memo[targetIdx][arrIdx] != -1) return memo[targetIdx][arrIdx];
    
    int result = dfs(targetIdx, arrIdx + 1);
    if (arr[arrIdx] == target[targetIdx]) {
        int candidate = dfs(targetIdx + 1, arrIdx + 1);
        if (candidate < result) result = candidate;
    }
    
    return memo[targetIdx][arrIdx] = result;
}

int minOperations() {
    memset(memo, -1, sizeof(memo));
    int matched = dfs(0, 0);
    return targetSize - matched;
}

int main() {
    // Implementation for input parsing
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²×m)

For each of n target elements, we try m arr elements, with recursive depth of n

⚠ Quadratic Growth

Space Complexity

O(n×m)

Memoization table size plus recursion stack depth

⚡ Linearithmic Space

Constraints

1 ≤ target.length, arr.length ≤ 10⁵
1 ≤ target[i], arr[i] ≤ 10⁹
target contains distinct integers
arr can contain duplicate integers

36.2K Views

Medium-High Frequency

~25 min Avg. Time

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

Brute Force (Recursive with Memoization) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler