Subsequence With the Minimum Score - Practice Coding Problems

Subsequence With the Minimum Score - Problem

You're given two strings s and t, and your goal is to transform t into a subsequence of s by removing some characters from t.

Here's the challenge: minimize the "removal cost" of making this transformation!

How scoring works:

If you don't remove any characters: score = 0
If you remove characters at indices left (minimum) to right (maximum): score = right - left + 1

The key insight is that you want to remove characters in the most compact range possible. For example, removing characters at indices [2,3,4] costs 3, while removing [1,5,9] costs 9!

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

Remember: A subsequence maintains the relative order of characters, like "ace" from "abcde".

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: We can remove 'z' (index 1) from t to get "baa", which is a subsequence of s. The score is 1-1+1 = 1.

example_2.py — No Removal Needed

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

› Output: 3

💡 Note: No characters of t exist in s, so we must remove all characters. Score = 2-0+1 = 3.

example_3.py — Already Valid

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

› Output: 0

💡 Note: t is already a subsequence of s, so no removal needed. Score = 0.

Visualization

Tap to expand

Understanding the Visualization

Identify Matching Start

Find how much of the beginning already matches the target

Identify Matching End

Find how much of the ending already matches the target

Minimize Middle Removal

Remove the smallest middle section to connect start and end

Verify Solution

Ensure the remaining text forms a valid subsequence

Key Takeaway

🎯 Key Insight: The optimal solution always removes a contiguous middle section, maximizing the matching prefix and suffix portions we can keep.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) preprocessing + O(log n) binary search iterations × O(n) validation per iteration

⚡ Linearithmic

Space Complexity

O(n)

Space for left and right prefix arrays

⚡ Linearithmic Space

Constraints

1 ≤ s.length, t.length ≤ 10⁵
s and t consist of only lowercase English letters
Memory limit: 256 MB

Asked in

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

The optimal approach uses two-pointers with binary search in O(n log n) time. Key insight: we only need to remove a contiguous middle section from string t, keeping maximum matching prefixes and suffixes. First compute how much we can match from left and right sides, then binary search on the minimum removal window size.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + Preprocessing	O(n log n)	O(n)	Precompute matching positions, then binary search on removal window size
Two Pointers + Binary Search	O(n log n)	O(n)	Match maximum prefix and suffix, then binary search for minimum middle removal
Brute Force (Try All Ranges)	O(n³)	O(n)	Try removing every possible contiguous range from t and check if remainder is subsequence of s

Binary Search + Preprocessing — Algorithm Steps

Precompute left[i] = max characters of t we can match using s[0...i]
Precompute right[i] = max characters of t we can match using s[i...n-1]
Binary search on removal window size k
For each k, check if we can remove some window of size k and still match
Use left/right arrays to validate each removal window efficiently

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Left Array

left[i] = max chars of t matchable using s[0...i]

Build Right Array

right[i] = max chars of t matchable using s[i...n-1]

Binary Search

Search for minimum removal window size k

Validate Window

Check if removing window of size k works

Code -

solution.c — C

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

bool canAchieve(int k, int* left, int* right, int n, int m) {
    for (int start = 0; start <= m - k; start++) {
        int end = start + k - 1;
        int needLeft = start;
        int needRight = m - 1 - end;
        
        int leftPos = -1;
        if (needLeft > 0) {
            for (int i = 0; i < n; i++) {
                if (left[i] >= needLeft) {
                    leftPos = i;
                    break;
                }
            }
            if (leftPos == -1) continue;
        }
        
        int rightPos = n;
        if (needRight > 0) {
            for (int i = n - 1; i >= 0; i--) {
                if (right[i] >= needRight) {
                    rightPos = i;
                    break;
                }
            }
            if (rightPos == n) continue;
        }
        
        if (leftPos < rightPos) {
            return true;
        }
    }
    return false;
}

int minimumScore(const char* s, const char* t) {
    int n = strlen(s), m = strlen(t);
    
    int left[1001], right[1001];
    
    int j = 0;
    for (int i = 0; i < n; i++) {
        if (j < m && s[i] == t[j]) {
            j++;
        }
        left[i] = j;
    }
    
    j = m - 1;
    for (int i = n - 1; i >= 0; i--) {
        if (j >= 0 && s[i] == t[j]) {
            j--;
        }
        right[i] = m - 1 - j;
    }
    
    if (left[n - 1] == m) return 0;
    
    int lo = 1, hi = m;
    while (lo < hi) {
        int mid = (lo + hi) / 2;
        if (canAchieve(mid, left, right, n, m)) {
            hi = mid;
        } else {
            lo = mid + 1;
        }
    }
    
    return lo;
}

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", minimumScore(s, t));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) preprocessing + O(log n) binary search iterations × O(n) validation per iteration

⚡ Linearithmic

Space Complexity

O(n)

Space for left and right prefix arrays

⚡ Linearithmic Space

Constraints

1 ≤ s.length, t.length ≤ 10⁵
s and t consist of only lowercase English letters
Memory limit: 256 MB

52.0K Views

High Frequency

~25 min Avg. Time

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

Binary Search + Preprocessing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler