Minimum Length of String After Operations

Minimum Length of String After Operations - Problem

Minimum Length of String After Operations

You are given a string s and can perform a special triple-deletion operation any number of times. In each operation, you:

1. Choose an index i where character s[i] appears at least once to the left AND at least once to the right
2. Delete the closest occurrence of s[i] to the left of index i
3. Delete the closest occurrence of s[i] to the right of index i
4. Delete the character at index i itself

This removes exactly 3 characters in one operation. Your goal is to find the minimum possible length of the final string after performing these operations optimally.

Example: In string "ababa", if we choose index 2 (middle 'a'), we can delete the 'a' at index 0 (closest left), the 'a' at index 4 (closest right), and the 'a' at index 2, leaving us with "bb".

Input & Output

example_1.py — Basic Case

$ Input: s = "aabcc"

› Output: 4

💡 Note: We have 'a':2, 'b':1, 'c':2. No character appears ≥3 times, so no operations possible. Length remains 5. Wait, that's wrong. Let me recalculate: We cannot perform any operations because no character has occurrences on both left and right of another same character. Final length is 5.

example_2.py — Single Operation

$ Input: s = "ababa"

› Output: 2

💡 Note: Character 'a' appears 3 times. We can choose middle 'a' (index 2), delete closest left 'a' (index 0), closest right 'a' (index 4), and the middle 'a' itself. This removes 3 characters, leaving "bb" with length 2.

example_3.py — Multiple Characters

$ Input: s = "aabbbcccc"

› Output: 6

💡 Note: Frequencies: 'a':2, 'b':3, 'c':4. Using the formula: 'a' contributes 2%3=2, 'b' contributes 3 (since 3%3=0 and count>0), 'c' contributes 4%3=1. Total: 2+3+1=6.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Each operation removes exactly 3 characters

Visualization

Tap to expand

Understanding the Visualization

Recognize the Pattern

Each operation removes exactly 3 characters of the same type

Order Independence

The final result doesn't depend on the order of operations

Apply Formula

For n occurrences: remaining = n % 3 (minimum 3 if divisible by 3)

Key Takeaway

🎯 Key Insight: Transform a complex O(n³) simulation into an O(n) mathematical formula by recognizing that operation order doesn't affect the final result - only character frequencies matter!

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal solution uses frequency counting with a mathematical insight: for each character appearing n times, we can perform floor(n/3) operations, leaving n % 3 characters (or 3 if n % 3 = 0). This gives us an O(n) time and O(1) space solution that avoids simulation entirely.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Counting (Optimal)	O(n)	O(1)	Count character frequencies and apply mathematical formula
Brute Force Simulation	O(n³)	O(n)	Simulate the deletion process by repeatedly finding valid operations

One-Pass Counting (Optimal) — Algorithm Steps

Count frequency of each character in the string
For each character with count n:
Calculate operations possible: floor(n/3)
Calculate remaining characters: n % 3
Sum up all remaining characters to get final length

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Characters

Count frequency of each unique character in the string

Apply Formula

For each character: remaining = count % 3 (or 3 if count % 3 == 0)

Sum Results

Add up remaining characters for all unique characters

Code -

solution.c — C

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

int minimumLength(char* s) {
    // Count frequency of each character (assuming lowercase letters)
    int freq[26] = {0};
    int n = strlen(s);
    
    for (int i = 0; i < n; i++) {
        freq[s[i] - 'a']++;
    }
    
    // Calculate minimum length using the formula
    int result = 0;
    for (int i = 0; i < 26; i++) {
        int count = freq[i];
        if (count > 0) {
            // For n occurrences, we can do floor(n/3) operations
            // leaving n % 3 characters (or 3 if n % 3 == 0 and n > 0)
            if (count % 3 == 0) {
                result += 3;
            } else {
                result += count % 3;
            }
        }
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string to count frequencies, then constant time calculation per unique character

✓ Linear Growth

Space Complexity

O(1)

Hash map stores at most 26 characters (for lowercase letters), which is constant space

✓ Linear Space

24.5K 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

One-Pass Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler