Find Maximum Removals From Source String - Practice Coding Problems

Find Maximum Removals From Source String - Problem

Array Hash Table Two Pointers String Dynamic Programming Medium

Find Maximum Removals From Source String

You're given a string source of size n and a string pattern that is guaranteed to be a subsequence of source. You also have a sorted integer array targetIndices containing distinct indices in the range [0, n-1].

Your goal is to maximize the number of characters you can remove from source while ensuring that pattern remains a subsequence of the modified string.

Rules:
• You can only remove characters at indices present in targetIndices
• After each removal, pattern must still be a subsequence of source
• Character indices don't shift after removals (e.g., removing 'c' from "acb" keeps 'b' at index 2)

Example: If source = "abbaa", pattern = "aba", and targetIndices = [0, 1, 2], you could remove characters at indices 1 and 2, giving you "a_a" which still contains "aba" as a subsequence.

Input & Output

example_1.py — Basic Case

$ Input: source = "abbaa", pattern = "aba", targetIndices = [0, 1, 2]

› Output: 2

💡 Note: We can remove characters at indices 0 and 1. The resulting string "_baa" (where _ represents removed chars) still contains "aba" as a subsequence: 'a' from index 4, 'b' from index 2, 'a' from index 3.

example_2.py — No Removals Possible

$ Input: source = "bcda", pattern = "d", targetIndices = [0, 3]

› Output: 1

💡 Note: We can remove the character at index 0 ('b'), but we cannot remove the character at index 3 ('d') because it's needed for the pattern. So we can remove at most 1 character.

example_3.py — All Removable

$ Input: source = "yeyeyeyew", pattern = "yeye", targetIndices = [5, 6, 7, 8]

› Output: 4

💡 Note: The pattern "yeye" can be formed using characters at indices 0,1,2,3. All characters at indices 5,6,7,8 can be removed since they're not needed for the pattern.

Constraints

1 ≤ source.length ≤ 3 × 10³
1 ≤ pattern.length ≤ source.length
1 ≤ targetIndices.length ≤ source.length
targetIndices is sorted in ascending order
The integers in targetIndices are distinct
0 ≤ targetIndices[i] < source.length
pattern is guaranteed to be a subsequence of source
source and pattern consist only of lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Analyze Requirements

Build DP table to understand minimum characters needed at each position

Make Greedy Choices

At each target position, decide if removal is safe based on remaining needs

Preserve Pattern

Ensure the pattern remains a valid subsequence after each removal

Maximize Removals

Count the total number of safe removals possible

Key Takeaway

🎯 Key Insight: Dynamic programming tells us the minimum characters needed from each position, enabling safe greedy removal decisions that maximize deletions while preserving the subsequence property.

Asked in

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

The optimal solution uses dynamic programming combined with a greedy approach. First, we build a DP table to calculate the minimum number of characters needed from each position to complete the remaining pattern. Then, we iterate through the source string and greedily remove characters from targetIndices whenever it's safe (when we have enough remaining characters). Time: O(n×m), Space: O(n×m).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n × m + n)	O(n × m)	Use DP to track minimum characters needed and greedily remove from targetIndices
Brute Force (Try All Combinations)	O(2^k × n × m)	O(k)	Try every possible subset of targetIndices and check if pattern remains a subsequence

Dynamic Programming (Optimal) — Algorithm Steps

Create DP array where dp[i][j] = minimum chars needed from source[i:] to match pattern[j:]
Fill DP table backwards: if chars match, we can use this char; otherwise, we must skip
Convert targetIndices to set for O(1) lookup
Iterate forward through source, removing chars when it's safe (doesn't break pattern matching)
A removal is safe if we have enough remaining characters to complete the pattern

Visualization

Tap to expand

Step-by-Step Walkthrough

Build DP Table

Calculate minimum characters needed from each position to complete remaining pattern

Greedy Decision

At each target index, check if removal is safe based on remaining characters vs DP requirement

Safe Removal

Remove character if we have enough remaining characters to complete the pattern

Continue Matching

If can't remove, use character for pattern matching and continue

Code -

solution.c — C

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

int maxRemovals(char* source, char* pattern, int* targetIndices, int targetIndicesSize) {
    int n = strlen(source), m = strlen(pattern);
    
    // DP table
    int** dp = (int**)malloc((n + 1) * sizeof(int*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (int*)malloc((m + 1) * sizeof(int));
        for (int j = 0; j <= m; j++) {
            dp[i][j] = INT_MAX;
        }
        dp[i][m] = 0;
    }
    
    // Fill DP table backwards
    for (int i = n - 1; i >= 0; i--) {
        for (int j = m - 1; j >= 0; j--) {
            dp[i][j] = dp[i + 1][j];
            if (source[i] == pattern[j] && dp[i + 1][j + 1] != INT_MAX) {
                int newVal = 1 + dp[i + 1][j + 1];
                if (newVal < dp[i][j]) {
                    dp[i][j] = newVal;
                }
            }
        }
    }
    
    // Create target set
    bool targetSet[1001] = {false};
    for (int i = 0; i < targetIndicesSize; i++) {
        targetSet[targetIndices[i]] = true;
    }
    
    int removed = 0, i = 0, j = 0;
    
    // Greedy removal
    while (i < n && j < m) {
        if (targetSet[i]) {
            int remainingChars = n - i - 1;
            if (remainingChars >= dp[i + 1][j]) {
                removed++;
                i++;
                continue;
            }
        }
        
        if (source[i] == pattern[j]) {
            j++;
        }
        i++;
    }
    
    // Remove remaining
    while (i < n) {
        if (targetSet[i]) {
            removed++;
        }
        i++;
    }
    
    // Free memory
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return removed;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m + n)

O(nm) to fill DP table, O(n) for greedy removal decisions

✓ Linear Growth

Space Complexity

O(n × m)

DP table storing minimum characters needed for each state

⚡ Linearithmic Space

38.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

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler