Find Maximum Removals From Source String

Find Maximum Removals From Source String - Problem

Array Hash Table Two Pointers String Dynamic Programming Medium

You are given a string source of size n, a string pattern that is a subsequence of source, and a sorted integer array targetIndices that contains distinct numbers in the range [0, n - 1].

We define an operation as removing a character at an index idx from source such that:

idx is an element of targetIndices
pattern remains a subsequence of source after removing the character

Performing an operation does not change the indices of the other characters in source. For example, if you remove 'c' from "acb", the character at index 2 would still be 'b'.

Return the maximum number of operations that can be performed.

Input & Output

Example 1 — Basic Case

$ Input: source = "abcacb", pattern = "ab", targetIndices = [3,1,0]

› Output: 2

💡 Note: Remove characters at indices 3 and 1. After removal: "abcb" → pattern "ab" is still a subsequence.

Example 2 — Cannot Remove All

$ Input: source = "abcabc", pattern = "abc", targetIndices = [2,1,0]

› Output: 1

💡 Note: Can only remove one character while keeping pattern "abc" as subsequence.

Example 3 — No Removals Possible

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

› Output: 0

💡 Note: Pattern uses all characters, so no characters can be removed.

Constraints

1 ≤ source.length ≤ 3000
1 ≤ pattern.length ≤ source.length
1 ≤ targetIndices.length ≤ source.length
0 ≤ targetIndices[i] < source.length

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 10

The key insight is to greedily test character removals while ensuring the pattern remains a subsequence. The optimal approach uses dynamic programming to efficiently validate if a pattern can be formed after removals. Time: O(k × n), Space: O(n × m) for DP table.

Common Approaches

✓ Binary Search

⏱️ Time: N/A Space: N/A

Frequency Count

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

⏱️ Time: O(2^k × n) Space: O(k)

Generate all possible subsets of targetIndices, remove those characters from source, and check if pattern is still a subsequence. Return the maximum size subset that works.

Dynamic Programming - Optimal Solution

⏱️ Time: O(n × m + k × n) Space: O(n × m)

First find which characters are essential to form the pattern using dynamic programming. Then greedily remove non-essential characters from the target indices to maximize removals.

Greedy Approach

⏱️ Time: O(k × n) Space: O(1)

Iterate through targetIndices and for each index, try removing it. If the pattern is still a subsequence after removal, keep it removed. Otherwise, restore it and continue.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

bool canFormSubsequence(char* source, char* pattern, bool* removed, int sourceLen) {
    int patternLen = strlen(pattern);
    int i = 0, j = 0;
    
    while (i < sourceLen && j < patternLen) {
        if (!removed[i] && source[i] == pattern[j]) {
            j++;
        }
        i++;
    }
    
    return j == patternLen;
}

int solution(char* source, char* pattern, int* targetIndices, int targetSize) {
    int sourceLen = strlen(source);
    static bool removed[100000]; // Use static to avoid stack overflow
    memset(removed, false, sizeof(bool) * sourceLen);
    
    int removedCount = 0;
    
    // Try to remove indices in reverse order (greedy approach)
    for (int i = 0; i < targetSize; i++) {
        int idx = targetIndices[i];
        removed[idx] = true;
        
        if (canFormSubsequence(source, pattern, removed, sourceLen)) {
            removedCount++;
        } else {
            // Can't remove this index, revert
            removed[idx] = false;
        }
    }
    
    return removedCount;
}

int main() {
    char source[100000];
    char pattern[100000];
    char targetLine[1000000];
    
    // Read source string
    if (!fgets(source, sizeof(source), stdin)) return -1;
    source[strcspn(source, "\n")] = 0; // Remove newline
    
    // Read pattern string
    if (!fgets(pattern, sizeof(pattern), stdin)) return -1;
    pattern[strcspn(pattern, "\n")] = 0; // Remove newline
    
    // Read target indices array
    if (!fgets(targetLine, sizeof(targetLine), stdin)) return -1;
    targetLine[strcspn(targetLine, "\n")] = 0; // Remove newline
    
    // Parse target indices from format [3,1,0]
    static int targetIndices[100000]; // Use static to avoid stack overflow
    int targetSize = 0;
    
    char* ptr = strchr(targetLine, '[');
    if (!ptr) return -1;
    ptr++; // Skip '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr >= '0' && *ptr <= '9') {
            targetIndices[targetSize] = atoi(ptr);
            targetSize++;
            // Skip the number
            while (*ptr >= '0' && *ptr <= '9') ptr++;
        } else {
            ptr++;
        }
    }
    
    int result = solution(source, pattern, targetIndices, targetSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

8.9K Views

Medium Frequency

~25 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