Subsequence With the Minimum Score

Subsequence With the Minimum Score - Problem

You are given two strings s and t.

You are allowed to remove any number of characters from the string t.

The score of the string is 0 if no characters are removed from the string t, otherwise:

Let left be the minimum index among all removed characters.
Let right be the maximum index among all removed characters.

Then the score of the string is right - left + 1.

Return the minimum possible score to make t a subsequence of s.

A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., "ace" is a subsequence of "abcde" while "aec" is not).

Input & Output

Example 1 — Basic Case

$ Input: s = "abacaba", t = "bzc"

› Output: 2

💡 Note: Remove "bz" from t, leaving "c". The character "c" exists in s as a subsequence. Score = 1 - 0 + 1 = 2.

Example 2 — Already Subsequence

$ Input: s = "abcdef", t = "ace"

› Output: 0

💡 Note: t is already a subsequence of s, so no characters need to be removed. Score = 0.

Example 3 — Remove Middle

$ Input: s = "xyz", t = "xay"

› Output: 1

💡 Note: Remove "a" from position 1, leaving "xy" which is a subsequence of "xyz". Score = 1 - 1 + 1 = 1.

Constraints

1 ≤ s.length, t.length ≤ 10⁵
s and t consist of only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 A Amazon 6

The key insight is to find the minimum contiguous substring to remove from t such that the remaining characters form a subsequence of s. The optimal approach uses binary search on the answer combined with efficient subsequence checking. Time: O(n² log n), Space: O(1).

Common Approaches

✓ Binary Search on Answer

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

Use binary search to find the minimum score. For each candidate score, check if we can remove a substring of that length to make t a subsequence of s. This combines the efficiency of binary search with optimized subsequence checking.

Brute Force - Try All Substrings

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

For each possible left and right boundary, remove that substring from t and check if the remaining characters form a subsequence of s. Return the minimum score among valid removals.

Two Pointers - Match from Both Ends

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

Use two pointers to find the longest prefix of t that matches s and the longest suffix that matches the remainder of s. The gap between them needs to be removed.

Binary Search on Answer — Algorithm Steps

Binary search on answer from 0 to length of t
For each score, try all possible substrings of that length to remove
Check if remaining string forms subsequence of s

Visualization

Tap to expand

Step-by-Step Walkthrough

Search Space

Score range [1, length of t]

Check Midpoint

Can we achieve score = mid?

Narrow Range

Adjust search bounds based on result

Code -

solution.c — C

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

int isSubsequence(char* text, char* pattern) {
    int i = 0, patLen = strlen(pattern), textLen = strlen(text);
    for (int j = 0; j < textLen && i < patLen; j++) {
        if (text[j] == pattern[i]) {
            i++;
        }
    }
    return i == patLen;
}

int canAchieveScore(char* s, char* t, int score) {
    if (score == 0) {
        return isSubsequence(s, t);
    }
    
    int n = strlen(t);
    char* remaining = (char*)malloc((n + 1) * sizeof(char));
    
    for (int start = 0; start <= n - score; start++) {
        strncpy(remaining, t, start);
        strcpy(remaining + start, t + start + score);
        
        if (isSubsequence(s, remaining)) {
            free(remaining);
            return 1;
        }
    }
    
    free(remaining);
    return 0;
}

int solution(char* s, char* t) {
    int n = strlen(t);
    if (isSubsequence(s, t)) {
        return 0;
    }
    
    int left = 1, right = n;
    int result = n;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canAchieveScore(s, t, mid)) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

int main() {
    char s[1001], t[1001];
    fgets(s, sizeof(s), stdin);
    fgets(t, sizeof(t), stdin);
    s[strcspn(s, "\n")] = 0;
    t[strcspn(t, "\n")] = 0;
    printf("%d\n", solution(s, t));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

Binary search O(log n) × O(n²) to check all substrings of given length × O(n) subsequence check

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for binary search bounds and string indices

✓ Linear Space

8.5K Views

Medium Frequency

~35 min Avg. Time

234 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

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler