String Compression II - Practice Coding Problems

String Compression II - Problem

String Compression II presents an advanced optimization challenge involving run-length encoding with strategic character deletion.

You're given a string s and can delete at most k characters to minimize the compressed string's length. Run-length encoding replaces consecutive identical characters (2+ occurrences) with the character followed by its count. For example:

• "aabccc" → "a2bc3" (length 5)
• "aaabcccc" → "a3bc4" (length 5)

Single characters remain unchanged (no '1' is added). Your goal is to find the minimum possible length of the run-length encoded string after optimally deleting up to k characters.

Key insight: Sometimes deleting characters creates longer runs, which can result in shorter overall encoding!

Input & Output

example_1.py — Basic Optimization

$ Input: s = "aaabcccc", k = 2

› Output: 4

💡 Note: We can delete the 'b' and one 'c' to get "aaacc" which becomes "a3c2" (length 4). Alternatively, delete positions to create "aaacccc" → "a3c4" (length 4).

example_2.py — No Deletions Needed

$ Input: s = "aabbaa", k = 3

› Output: 2

💡 Note: We can delete 'bb' and one 'a' to get "aaa" which becomes "a3" (length 2). This is optimal since we're creating the longest possible run.

example_3.py — Edge Case

$ Input: s = "aaaaaaaaaaa", k = 0

› Output: 3

💡 Note: Cannot delete any characters. The string "aaaaaaaaaaa" (11 a's) becomes "a11" which has length 3 (character + two digits).

Visualization

Tap to expand

Understanding the Visualization

Analyze Runs

Identify consecutive character groups and their compression potential

Strategic Deletion

Delete characters to merge distant runs of the same character

Count Encoding

Apply run-length encoding rules: single=1, 2-9=2chars, 10-99=3chars, 100+=4chars

Minimize Length

Find the deletion strategy that produces the shortest encoded result

Key Takeaway

🎯 Key Insight: The optimal solution uses dynamic programming to explore all deletion possibilities while memoizing results. Strategic character removal can merge distant character groups into longer runs, ultimately producing shorter compressed strings than keeping all characters.

Time & Space Complexity

Time Complexity

⏱️

O(n * k * n * n)

n positions × k deletions × n possible characters × n possible counts, with memoization

✓ Linear Growth

Space Complexity

O(n * k * n * n)

Memoization table stores states for position, deletions, character, and count

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 100
0 ≤ k ≤ s.length
s contains only lowercase English letters
The goal is to minimize the run-length encoded string length

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses dynamic programming with memoization to track the minimum encoding length at each position. The key insight is that deleting characters strategically can create longer consecutive runs, reducing the overall compressed length. The DP state tracks position, remaining deletions, last character, and current count, making optimal keep/delete decisions at each step.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n * k * n * n)	O(n * k * n * n)	Use memoized DP to track optimal compression at each position with remaining deletions
Brute Force (Try All Combinations)	O(2^n * n)	O(n)	Generate all possible ways to delete at most k characters and find minimum compression

Dynamic Programming (Optimal) — Algorithm Steps

Define DP state: dp(pos, k, last_char, count) = minimum encoding length
For each position, try keeping or deleting the current character
If keeping, update character count and calculate encoding contribution
Use memoization to avoid recomputing the same subproblems
Handle encoding rules: single chars = 1, counts 2-9 = 2, counts 10-99 = 3, etc.

Visualization

Tap to expand

Step-by-Step Walkthrough

State Definition

dp(pos, k, last_char, count) tracks position, remaining deletions, and current run

Decision Tree

At each position, choose to keep or delete current character

Count Encoding

Track how character counts affect encoding length (1→1, 2→2, 10→3, 100→4)

Memoization

Cache results to avoid recomputing same subproblems

Code -

solution.c — C

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

#define MAXN 105
#define MAXK 105

int memo[MAXN][MAXK][27][MAXN];
int initialized = 0;

void initMemo() {
    if (initialized) return;
    for (int i = 0; i < MAXN; i++) {
        for (int j = 0; j < MAXK; j++) {
            for (int k = 0; k < 27; k++) {
                for (int l = 0; l < MAXN; l++) {
                    memo[i][j][k][l] = -1;
                }
            }
        }
    }
    initialized = 1;
}

int dp(char* s, int len, int pos, int remainingK, int lastChar, int count) {
    if (remainingK < 0) return INT_MAX / 2;
    if (pos == len) return 0;
    
    if (memo[pos][remainingK][lastChar][count] != -1) {
        return memo[pos][remainingK][lastChar][count];
    }
    
    // Option 1: Delete current character
    int result = dp(s, len, pos + 1, remainingK - 1, lastChar, count);
    
    // Option 2: Keep current character
    int currentChar = s[pos] - 'a' + 1; // Map 'a'-'z' to 1-26, 0 reserved for space
    if (currentChar == lastChar) {
        int newCount = count + 1;
        int additional = 0;
        if (newCount == 2) {
            additional = 1;
        } else if (newCount == 10 || newCount == 100) {
            additional = 1;
        }
        
        int temp = dp(s, len, pos + 1, remainingK, currentChar, newCount);
        if (temp != INT_MAX / 2) {
            result = (result < additional + temp) ? result : (additional + temp);
        }
    } else {
        int temp = dp(s, len, pos + 1, remainingK, currentChar, 1);
        if (temp != INT_MAX / 2) {
            result = (result < 1 + temp) ? result : (1 + temp);
        }
    }
    
    return memo[pos][remainingK][lastChar][count] = result;
}

int getLengthOfOptimalCompression(char* s, int k) {
    initMemo();
    return dp(s, strlen(s), 0, k, 0, 0);
}

int main() {
    char s[101];
    int k;
    fgets(s, sizeof(s), stdin);
    // Remove quotes and newline
    char* start = strchr(s, '"');
    if (start) {
        start++;
        char* end = strrchr(start, '"');
        if (end) *end = '\0';
        memmove(s, start, strlen(start) + 1);
    } else {
        // Remove newline if no quotes
        s[strcspn(s, "\n")] = '\0';
    }
    scanf("%d", &k);
    printf("%d\n", getLengthOfOptimalCompression(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * k * n * n)

n positions × k deletions × n possible characters × n possible counts, with memoization

✓ Linear Growth

Space Complexity

O(n * k * n * n)

Memoization table stores states for position, deletions, character, and count

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 100
0 ≤ k ≤ s.length
s contains only lowercase English letters
The goal is to minimize the run-length encoded string length

43.7K Views

Medium-High Frequency

~35 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler