Minimum Operations to Make a Subsequence

Minimum Operations to Make a Subsequence - Problem

You are given an array target that consists of distinct integers and another integer array arr that can have duplicates.

In one operation, you can insert any integer at any position in arr. For example, if arr = [1,4,1,2], you can add 3 in the middle and make it [1,4,3,1,2]. Note that you can insert the integer at the very beginning or end of the array.

Return the minimum number of operations needed to make target a subsequence of arr.

A subsequence of an array is a new array generated from the original array by deleting some elements (possibly none) without changing the remaining elements' relative order. For example, [2,7,4] is a subsequence of [4,2,3,7,2,1,4] (the underlined elements), while [2,4,2] is not.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Only element 3 from target appears in arr at the correct relative position. We need to insert 5 and 1, so 2 operations are needed.

Example 2 — Multiple Elements Match

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

› Output: 3

💡 Note: The longest subsequence we can form is [4,6,8] or [4,2,3] or [6,8] etc. The optimal is length 3, so we need 6-3=3 operations.

Example 3 — No Common Elements

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

› Output: 3

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

Constraints

1 ≤ target.length ≤ 10⁵
1 ≤ arr.length ≤ 10⁵
1 ≤ target[i], arr[i] ≤ 10⁹
All elements in target are distinct

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8

The key insight is to transform this into a Longest Increasing Subsequence (LIS) problem. Map each target element to its position, then find the LIS of positions from arr elements. Best approach uses binary search for LIS with Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force - Direct Subsequence Matching

⏱️ Time: O(n + m) Space: O(1)

Use two pointers to traverse both arrays and find the longest matching subsequence. The answer is the number of elements we need to insert.

Hash Map + LIS Transformation

⏱️ Time: O(n²) Space: O(n + k)

Map each target element to its position, then transform arr elements to their positions in target. Find LIS of these positions to get the longest common subsequence.

Optimized LIS with Binary Search

⏱️ Time: O(n log n + m log m) Space: O(n + m)

After mapping elements to positions, use the optimized LIS algorithm with binary search to find the longest increasing subsequence efficiently.

Brute Force - Direct Subsequence Matching — Algorithm Steps

Use two pointers i for target and j for arr
When elements match, advance both pointers
Count matched elements and subtract from target length

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set pointers i=0, j=0 for target and arr

Match Elements

Advance both pointers when elements match

Calculate Result

Operations needed = target.length - matched

Code -

solution.c — C

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

int lengthOfLIS(int* nums, int size) {
    if (size == 0) return 0;
    
    int* dp = (int*)malloc(size * sizeof(int));
    for (int i = 0; i < size; i++) dp[i] = 1;
    
    for (int i = 1; i < size; i++) {
        for (int j = 0; j < i; j++) {
            if (nums[j] < nums[i]) {
                dp[i] = (dp[j] + 1 > dp[i]) ? dp[j] + 1 : dp[i];
            }
        }
    }
    
    int maxLen = 0;
    for (int i = 0; i < size; i++) {
        if (dp[i] > maxLen) maxLen = dp[i];
    }
    
    free(dp);
    return maxLen;
}

int solution(int* target, int targetSize, int* arr, int arrSize) {
    // Simple hash map using array (assuming values are small)
    int posMap[100001];
    memset(posMap, -1, sizeof(posMap));
    
    for (int i = 0; i < targetSize; i++) {
        if (target[i] >= 0 && target[i] <= 100000) {
            posMap[target[i]] = i;
        }
    }
    
    int positions[100000];
    int posCount = 0;
    
    for (int i = 0; i < arrSize; i++) {
        if (arr[i] >= 0 && arr[i] <= 100000 && posMap[arr[i]] != -1) {
            positions[posCount++] = posMap[arr[i]];
        }
    }
    
    int lisLength = lengthOfLIS(positions, posCount);
    return targetSize - lisLength;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int target[1000], arr[100000];
    int targetSize = 0, arrSize = 0;
    
    // Parse first array
    char* ptr = strtok(line1, "[],\n ");
    while (ptr != NULL) {
        target[targetSize++] = atoi(ptr);
        ptr = strtok(NULL, "[],\n ");
    }
    
    // Parse second array
    ptr = strtok(line2, "[],\n ");
    while (ptr != NULL) {
        arr[arrSize++] = atoi(ptr);
        ptr = strtok(NULL, "[],\n ");
    }
    
    int result = solution(target, targetSize, arr, arrSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through both arrays with two pointers

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

456 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 - Direct Subsequence Matching — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler