Maximum Deletions on a String

Maximum Deletions on a String - Problem

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

Delete the entire string s, or
Delete the first i letters of s if the first i letters of s are equal to the following i letters in s, for any i in the range 1 <= i <= s.length / 2.

For example, if s = "ababc", then in one operation, you could delete the first two letters of s to get "abc", since the first two letters of s and the following two letters of s are both equal to "ab".

Return the maximum number of operations needed to delete all of s.

Input & Output

Example 1 — Basic Case

$ Input: s = "ababc"

› Output: 2

💡 Note: First operation: delete "ab" (first 2 chars match next 2 chars), leaving "abc". Second operation: delete entire remaining string "abc". Total: 2 operations.

Example 2 — No Matching Prefix

$ Input: s = "abc"

› Output: 1

💡 Note: No matching prefix found ("a" ≠ "b"), so we can only delete the entire string in one operation.

Example 3 — Repeated Pattern

$ Input: s = "abab"

› Output: 2

💡 Note: First operation: delete "ab" (matches next "ab"), leaving "ab". Second operation: delete remaining "ab". Total: 2 operations.

Constraints

1 ≤ s.length ≤ 1000
s consists of only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to use dynamic programming to find the maximum number of deletion operations. At each position, we can either delete the entire remaining string or find a matching prefix to delete and recurse on the remaining substring. Best approach is bottom-up DP with Time: O(n³), Space: O(n).

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Use a DP array where dp[i] represents the maximum operations starting from position i. Fill the array from right to left, considering all possible prefix deletions at each position.

Dynamic Programming with Memoization

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

Same recursive approach but store results of subproblems in a memo dictionary. This eliminates redundant calculations when the same substring position is visited multiple times.

Recursive Brute Force

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

For each position in the string, check if we can delete a prefix by comparing it with the next segment of the same length. Recursively solve for the remaining string and take the maximum operations.

Bottom-Up Dynamic Programming — Algorithm Steps

Create DP array of size n+1
Fill from right to left
For each position, try all valid prefix deletions

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create DP array with base cases

Fill Table

Calculate each position using previous results

Result

Return dp[0] as final answer

Code -

solution.c — C

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

int solution(char* s) {
    int n = strlen(s);
    int* dp = (int*)calloc(n + 1, sizeof(int));
    
    // Fill DP table from right to left
    for (int i = n - 1; i >= 0; i--) {
        // Option 1: Delete entire remaining string
        dp[i] = 1;
        
        // Option 2: Delete matching prefix
        int remainingLen = n - i;
        for (int prefixLen = 1; prefixLen <= remainingLen / 2; prefixLen++) {
            if (i + 2 * prefixLen <= n) {
                int match = 1;
                for (int j = 0; j < prefixLen; j++) {
                    if (s[i + j] != s[i + prefixLen + j]) {
                        match = 0;
                        break;
                    }
                }
                if (match) {
                    int ops = 1 + dp[i + prefixLen];
                    if (ops > dp[i]) {
                        dp[i] = ops;
                    }
                }
            }
        }
    }
    
    int result = dp[0];
    free(dp);
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    printf("%d\n", solution(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n) positions, each checking O(n) prefixes with O(n) string comparison

⚠ Quadratic Growth

Space Complexity

O(n)

DP array stores one value per position

⚡ Linearithmic Space

15.0K Views

Medium Frequency

~35 min Avg. Time

450 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

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler