Minimum Length of String After Deleting Similar Ends

Minimum Length of String After Deleting Similar Ends - Problem

You're given a string s containing only the characters 'a', 'b', and 'c'. Your task is to apply a string reduction operation any number of times to minimize the string's length.

The operation works as follows:
• Choose a non-empty prefix where all characters are identical
• Choose a non-empty suffix where all characters are identical
• The prefix and suffix must not overlap
• The prefix and suffix must contain the same character
• Delete both the prefix and suffix simultaneously

For example, with "cabaac", you could remove prefix "c" and suffix "c" to get "abaa", then remove prefix "a" and suffix "aa" to get "b".

Goal: Return the minimum possible length after performing this operation optimally.

Input & Output

example_1.py — Basic Case

$ Input: s = "ca"

› Output: 2

💡 Note: No valid operations can be performed since we need both prefix and suffix with the same character, but 'c' ≠ 'a'.

example_2.py — Multiple Operations

$ Input: s = "cabaac"

› Output: 1

💡 Note: First, remove prefix "c" and suffix "c" to get "abaa". Then remove prefix "a" and suffix "aa" to get "b". Final length is 1.

example_3.py — Complete Removal

$ Input: s = "aabccabba"

› Output: 3

💡 Note: Remove prefix "aa" and suffix "a" to get "bccabb". Then remove prefix "b" and suffix "bb" to get "cca". No more operations possible, final length is 3.

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of characters 'a', 'b', and 'c'

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Place pointers at both ends of the string

Check Match

If end characters match, we can remove them

Maximize Removal

Remove as many matching characters as possible from both ends

Continue

Repeat until no more matching pairs exist

Final Result

Return the length of remaining characters

Key Takeaway

🎯 Key Insight: Greedy removal of maximum matching characters from both ends always gives the optimal result, since there's no advantage to saving them for later operations.

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal approach uses a two-pointer technique that greedily removes matching characters from both ends. Start pointers at both ends, and when they point to the same character, extend as far as possible on both sides to remove the maximum number of matching characters. This greedy strategy is optimal because there's never an advantage to saving matching end characters for later removal. The algorithm runs in O(n) time with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Brute Force	O(3^n)	O(n)	Try all possible prefix-suffix combinations recursively
Two Pointers (Optimal)	O(n)	O(1)	Use two pointers from both ends, greedily removing matching characters

Recursive Brute Force — Algorithm Steps

For each character ('a', 'b', 'c'), find all possible prefix lengths with that character
For the same character, find all possible suffix lengths
Ensure prefix and suffix don't overlap
Recursively apply the operation on the remaining string
Return the minimum length across all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with the original string

Find Matching Ends

Look for all possible prefix-suffix pairs with same character

Try All Combinations

Recursively try removing each valid combination

Return Minimum

Return the minimum length found across all branches

Code -

solution.c — C

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

int solve(char* str, int len) {
    if (len <= 1) {
        return len;
    }
    
    int minLen = len;
    char chars[] = {'a', 'b', 'c'};
    
    for (int i = 0; i < 3; i++) {
        char c = chars[i];
        
        // Find prefix length
        int prefixLen = 0;
        while (prefixLen < len && str[prefixLen] == c) {
            prefixLen++;
        }
        
        if (prefixLen == 0) continue;
        
        // Find suffix length
        int suffixLen = 0;
        while (suffixLen < len && str[len - 1 - suffixLen] == c) {
            suffixLen++;
        }
        
        // Try all combinations
        for (int p = 1; p <= prefixLen; p++) {
            for (int sLen = 1; sLen <= suffixLen; sLen++) {
                if (p + sLen <= len) {
                    int newLen = len - p - sLen;
                    char* remaining = malloc(newLen + 1);
                    strncpy(remaining, str + p, newLen);
                    remaining[newLen] = '\0';
                    
                    int result = solve(remaining, newLen);
                    if (result < minLen) {
                        minLen = result;
                    }
                    free(remaining);
                }
            }
        }
    }
    
    return minLen;
}

int minimumLength(char* s) {
    return solve(s, strlen(s));
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline and quotes
    int len = strlen(s);
    if (s[len-1] == '\n') s[--len] = '\0';
    if (s[0] == '"' && s[len-1] == '"') {
        s[len-1] = '\0';
        memmove(s, s+1, len-1);
    }
    
    printf("%d\n", minimumLength(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

In worst case, we have 3 choices (a, b, c) at each recursion level, and we can have up to n levels

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth can go up to n in worst case

⚡ Linearithmic Space

28.6K Views

Medium Frequency

~15 min Avg. Time

892 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

Recursive Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler