Maximum Score From Removing Substrings - Practice Coding Problems

Maximum Score From Removing Substrings - Problem

You're given a string s and two integers x and y representing points you can earn by removing specific substrings. Your goal is to maximize your total points by strategically removing substrings.

Two operations available:

Remove "ab" - Gain x points
Remove "ba" - Gain y points

Example: In string "cabxbae" with x=5, y=4:
• Remove "ab" → "cxbae" (+5 points)
• Remove "ba" → "cxe" (+4 points)
• Total: 9 points

The key insight is that you should be greedy - always prioritize removing the substring that gives more points first, as this maximizes your total score.

Input & Output

example_1.py — Basic Case

$ Input: s = "caba", x = 5, y = 4

› Output: 5

💡 Note: Remove 'ab' from 'caba' to get 'ca' and gain 5 points. No more 'ab' or 'ba' substrings exist. Total: 5 points.

example_2.py — Multiple Removals

$ Input: s = "aabbaaxybbaabb", x = 5, y = 4

› Output: 20

💡 Note: Remove all 'ab' first (higher value): 4 'ab' substrings × 5 = 20 points. Then check for remaining 'ba' patterns.

example_3.py — Edge Case

$ Input: s = "aabb", x = 1, y = 2

› Output: 2

💡 Note: Since y > x, prioritize 'ba'. Remove 'ba' from middle to get 'ab', then remove 'ab'. Total: 2 + 1 = 3... Wait, that's wrong. Actually: 'aabb' → can only remove 'ab' once for 1 point, then 'ab' again for 1 point = 2 total.

Constraints

1 ≤ s.length ≤ 10⁵
1 ≤ x, y ≤ 10⁴
s consists of lowercase English letters only
Key insight: Greedy approach always works - prioritize higher value first

Visualization

Tap to expand

Understanding the Visualization

Choose Strategy

Determine which package type gives more profit ($x for 'ab' vs $y for 'ba')

First Production Line

Process conveyor belt, packaging all high-value combinations immediately when possible

Second Production Line

Process remaining items for any lower-value packaging opportunities

Count Revenue

Sum up all earnings from both production lines for maximum profit

Key Takeaway

🎯 Key Insight: The greedy strategy works because prioritizing higher-value substring removals never prevents us from achieving the optimal solution - there's no benefit to removing lower-value patterns first.

Asked in

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

The optimal solution uses a greedy approach with stack processing. Key insight: always prioritize removing the higher-value substring first ('ab' if x > y, 'ba' if y > x). Make two passes through the string - first pass removes all high-value patterns using a stack, second pass processes the remaining string for low-value patterns. This achieves O(n) time complexity and is provably optimal.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n)	O(n²)	Try all possible orders of removing 'ab' and 'ba' substrings
Greedy Stack Approach (Optimal)	O(n)	O(n)	Use greedy strategy with stack to prioritize higher-value removals

Brute Force (Try All Combinations) — Algorithm Steps

For current string, find all 'ab' and 'ba' occurrences
For each 'ab' found, recursively solve after removing it (add x points)
For each 'ba' found, recursively solve after removing it (add y points)
Return the maximum score among all possibilities
Use memoization to avoid recomputing same string states

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with the original string and identify all possible ab/ba removals

Branch for Each Option

Create branches for each possible substring removal

Recursive Exploration

Continue branching until no more ab/ba substrings exist

Backtrack & Compare

Return the maximum score found across all branches

Code -

solution.c — C

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

#define MAX_MEMO 10000

typedef struct {
    char* key;
    int value;
} MemoItem;

MemoItem memo[MAX_MEMO];
int memoSize = 0;

int findMemo(char* s) {
    for (int i = 0; i < memoSize; i++) {
        if (strcmp(memo[i].key, s) == 0) {
            return memo[i].value;
        }
    }
    return -1;
}

void addMemo(char* s, int value) {
    if (memoSize < MAX_MEMO) {
        memo[memoSize].key = strdup(s);
        memo[memoSize].value = value;
        memoSize++;
    }
}

int hasSubstring(char* s, char* sub) {
    return strstr(s, sub) != NULL;
}

int dfs(char* s, int x, int y) {
    int cached = findMemo(s);
    if (cached != -1) {
        return cached;
    }
    
    if (!hasSubstring(s, "ab") && !hasSubstring(s, "ba")) {
        addMemo(s, 0);
        return 0;
    }
    
    int maxScore = 0;
    int len = strlen(s);
    
    // Try removing each 'ab'
    for (int i = 0; i < len - 1; i++) {
        if (s[i] == 'a' && s[i+1] == 'b') {
            char* newString = malloc(len - 1);
            strncpy(newString, s, i);
            strcpy(newString + i, s + i + 2);
            int score = x + dfs(newString, x, y);
            if (score > maxScore) maxScore = score;
            free(newString);
        }
    }
    
    // Try removing each 'ba'
    for (int i = 0; i < len - 1; i++) {
        if (s[i] == 'b' && s[i+1] == 'a') {
            char* newString = malloc(len - 1);
            strncpy(newString, s, i);
            strcpy(newString + i, s + i + 2);
            int score = y + dfs(newString, x, y);
            if (score > maxScore) maxScore = score;
            free(newString);
        }
    }
    
    addMemo(s, maxScore);
    return maxScore;
}

int maximumGain(char* s, int x, int y) {
    memoSize = 0;
    return dfs(s, x, y);
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each position can be part of multiple removal operations, leading to exponential branching

⚠ Quadratic Growth

Space Complexity

O(n²)

Recursion stack depth and memoization table storing string states

⚠ Quadratic Space

42.4K Views

High Frequency

~18 min Avg. Time

1.8K 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler