Maximum Deletions on a String - Practice Coding Problems

Maximum Deletions on a String - Problem

Imagine you're playing a word-destruction game where you need to strategically delete parts of a string to maximize your score! 🎯

You are given a string s consisting of only lowercase English letters. In each operation, you can choose one of two actions:

Delete the entire string s (this ends the game), or
Delete the first i letters of s if the first i letters match exactly with the following i letters, where 1 ≤ i ≤ s.length / 2

Example: If s = "ababc", you can delete the first 2 letters ("ab") because they match the next 2 letters ("ab"), leaving you with "abc".

Your goal is to find the maximum number of operations needed to completely delete the string. Think of it as maximizing your score by making as many strategic moves as possible!

Input & Output

example_1.py — Basic Case

$ Input: s = "abcabcdabc"

› Output: 2

💡 Note: First operation: delete "abc" (first 3 letters match next 3 letters), leaving "abcdabc". Second operation: delete the entire remaining string "abcdabc". Total operations = 2.

example_2.py — Repeated Pattern

$ Input: s = "ababab"

› Output: 3

💡 Note: First: delete "ab" leaving "abab". Second: delete "ab" leaving "ab". Third: delete remaining "ab". Total = 3 operations.

example_3.py — No Valid Prefix

$ Input: s = "abcdef"

› Output: 1

💡 Note: No prefix matches the following substring of same length, so we can only delete the entire string in 1 operation.

Visualization

Tap to expand

Understanding the Visualization

Identify Valid Peels

Find all positions where the prefix matches the following substring of equal length

Recursive Exploration

For each valid peel, recursively solve for the remaining string after the deletion

Memoization

Cache results to avoid recalculating the same subproblems multiple times

Optimal Choice

Choose the deletion strategy that maximizes the total number of operations

Key Takeaway

🎯 Key Insight: The optimal approach uses dynamic programming with memoization, combined with LCP preprocessing for efficient string matching. Each position represents a state where we maximize operations by trying all valid prefix deletions.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n²) for preprocessing LCP array + O(n²) for DP with each state computed once

⚠ Quadratic Growth

Space Complexity

O(n²)

O(n²) for LCP array + O(n) for memoization array

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 4000
s consists of only lowercase English letters
The string is non-empty

Asked in

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

The optimal solution uses dynamic programming with memoization combined with LCP (Longest Common Prefix) preprocessing. We precompute an O(n²) LCP array to enable O(1) substring comparisons, then use memoized recursion to explore all valid prefix deletions while avoiding repeated subproblems. The key insight is that each position has an optimal solution that depends only on future positions, making it perfect for memoization.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Recursion	O(2^n)	O(n)	Try all possible deletion sequences recursively without memoization
Dynamic Programming with Memoization (Optimal)	O(n²)	O(n²)	Use memoized recursion to avoid recalculating same subproblems

Brute Force Recursion — Algorithm Steps

Start with the full string
For each possible prefix length i from 1 to n/2, check if s[0:i] == s[i:2i]
If match found, recursively solve for the remaining substring s[2i:]
Take the maximum of all valid recursive calls + 1
Base case: return 1 when no valid prefix deletions exist (delete entire string)

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with full string

Begin with the complete input string

Check all prefixes

For each possible prefix length, check if it matches the next substring

Recursive calls

Make recursive calls for each valid deletion, building a tree of possibilities

Return maximum

Take the maximum operations from all branches

Code -

solution.c — C

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

int solve(char* s, int len) {
    if (len == 0) return 0;
    
    int maxOps = 1; // Always can delete entire string
    
    // Try all possible prefix lengths
    for (int i = 1; i <= len / 2; i++) {
        int match = 1;
        for (int j = 0; j < i; j++) {
            if (s[j] != s[i + j]) {
                match = 0;
                break;
            }
        }
        
        if (match) {
            int ops = 1 + solve(s + 2 * i, len - 2 * i);
            if (ops > maxOps) maxOps = ops;
        }
    }
    
    return maxOps;
}

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

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we have exponential branching as each position might have multiple valid deletions

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth is at most n levels deep

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 4000
s consists of only lowercase English letters
The string is non-empty

23.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler