Maximum Score From Removing Substrings

Maximum Score From Removing Substrings - Problem

You are given a string s and two integers x and y. You can perform two types of operations any number of times:

Remove substring "ab" and gain x points.
For example, when removing "ab" from "cabxbae" it becomes "cxbae".

Remove substring "ba" and gain y points.
For example, when removing "ba" from "cabxbae" it becomes "cabxe".

Return the maximum points you can gain after applying the above operations on s.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Remove the substring "ab" at positions 1-2 to get "ca", earning 2 points. No more "ab" or "ba" pairs can be formed. Total score: 2.

Example 2 — Higher Y Value

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

› Output: 2

💡 Note: Since y > x, we prioritize "ba" pairs, but "aabb" contains no "ba" substrings. We can form 2 "ab" pairs for 2×1 = 2 points total.

Example 3 — No Pairs Possible

$ Input: s = "aaa", x = 3, y = 4

› Output: 0

💡 Note: String contains only 'a' characters, so no "ab" or "ba" substrings can be formed. Total score: 0.

Constraints

1 ≤ s.length ≤ 10⁵
1 ≤ x, y ≤ 10⁴
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 12

The key insight is to use a greedy approach: always remove the higher-value substring first. Use a stack to efficiently find and remove pairs in O(n) time. Best approach is the greedy stack method with two passes. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Removal Sequences

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

For each position in the string, if we find "ab" or "ba", recursively try removing it and continue with the remaining string. Return the maximum score among all possible removal sequences.

Greedy - Remove Higher Value Pairs First

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

The key insight is that we should prioritize removing the substring that gives more points. If x > y, remove all 'ab' pairs first, then 'ba'. Otherwise, remove 'ba' first, then 'ab'.

Stack Optimization - Single Pass

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

Instead of two separate passes, we can optimize by processing characters once and using stack operations to handle both types of pairs efficiently based on their values.

Brute Force - Try All Removal Sequences — Algorithm Steps

Scan string for "ab" and "ba" substrings
For each found substring, recursively remove it and calculate score
Try both removal orders and return maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Pairs

Scan string for all ab and ba pairs

Branch

Recursively try removing each pair

Maximum

Return highest score from all branches

Code -

solution.c — C

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

int backtrack(char* s, int x, int y) {
    int len = strlen(s);
    int hasAB = 0, hasBA = 0;
    
    for (int i = 0; i < len - 1; i++) {
        if (s[i] == 'a' && s[i+1] == 'b') hasAB = 1;
        if (s[i] == 'b' && s[i+1] == 'a') hasBA = 1;
    }
    
    if (!hasAB && !hasBA) return 0;
    
    int maxScore = 0;
    // Try removing all 'ab'
    for (int i = 0; i < len - 1; i++) {
        if (s[i] == 'a' && s[i+1] == 'b') {
            char* newS = malloc(len + 1);
            strncpy(newS, s, i);
            strcpy(newS + i, s + i + 2);
            int score = x + backtrack(newS, x, y);
            if (score > maxScore) maxScore = score;
            free(newS);
        }
    }
    
    // Try removing all 'ba'
    for (int i = 0; i < len - 1; i++) {
        if (s[i] == 'b' && s[i+1] == 'a') {
            char* newS = malloc(len + 1);
            strncpy(newS, s, i);
            strcpy(newS + i, s + i + 2);
            int score = y + backtrack(newS, x, y);
            if (score > maxScore) maxScore = score;
            free(newS);
        }
    }
    
    return maxScore;
}

int solution(char* s, int x, int y) {
    return backtrack(s, x, y);
}

int main() {
    char s[100001];
    int x, y;
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    scanf("%d", &x);
    scanf("%d", &y);
    
    int result = solution(s, x, y);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each character can be part of multiple removal sequences, leading to exponential branching

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack can go up to n levels deep

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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 Removal Sequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler