Find the Original Typed String II

Find the Original Typed String II - Problem

Alice is attempting to type a specific string on her computer. However, she tends to be clumsy and may press a key for too long, resulting in a character being typed multiple times.

You are given a string word, which represents the final output displayed on Alice's screen. You are also given a positive integer k.

Return the total number of possible original strings that Alice might have intended to type, if she was trying to type a string of size at least k.

Since the answer may be very large, return it modulo 10^9 + 7.

Input & Output

Example 1 — Basic Case

$ Input: word = "aabbcc", k = 4

› Output: 7

💡 Note: Groups are [2,2,2]. We can shorten each group to length 1 or 2. Valid combinations with length ≥ 4: (1,1,2), (1,2,1), (1,2,2), (2,1,1), (2,1,2), (2,2,1), (2,2,2) = 7 ways

Example 2 — Minimum Length

$ Input: word = "aa", k = 1

› Output: 2

💡 Note: Group is [2]. We can shorten to length 1 or 2. Both meet k=1 requirement, so 2 ways total

Example 3 — High Requirement

$ Input: word = "aab", k = 5

› Output: 0

💡 Note: Groups are [2,1]. Maximum possible length is 2+1=3, which is less than k=5, so 0 ways

Constraints

1 ≤ word.length ≤ 2000
word consists of lowercase English letters
1 ≤ k ≤ 2000

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to group consecutive identical characters and count ways to shorten each group while maintaining minimum length k. Best approach uses dynamic programming to efficiently count valid combinations. Time: O(n × k × max_group), Space: O(n × k)

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(n × k × max_group_size) Space: O(n × k)

Use bottom-up DP with a 2D table where dp[i][j] represents the number of ways to form strings of length j using first i groups. Build solution iteratively from smaller subproblems.

Brute Force Recursion

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

For each group of consecutive identical characters, recursively try all possible lengths from 1 to the group size. Count valid combinations that result in strings of length ≥ k.

Dynamic Programming with Memoization

⏱️ Time: O(n × k × max_group_size) Space: O(n × k)

Use memoization to store results of subproblems. For each position and remaining length needed, cache the number of valid ways to complete the string.

Bottom-Up Dynamic Programming — Algorithm Steps

Create DP table dp[groups][length]
Fill base cases
For each group and length, sum ways from previous group with all possible current group lengths
Sum all dp[groups][j] where j >= k

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Table

Create dp[groups][length] table

Fill Iteratively

For each group and length, compute ways

Sum Results

Add all dp[n][j] where j >= k

Code -

solution.c — C

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

#define MOD 1000000007
#define min(a, b) ((a) < (b) ? (a) : (b))

int solution(char* word, int k) {
    int len = strlen(word);
    int groups[1000];
    int groupCount = 0;
    int maxLen = 0;
    
    // Find groups of consecutive characters
    int i = 0;
    while (i < len) {
        int j = i;
        while (j < len && word[j] == word[i]) {
            j++;
        }
        groups[groupCount] = j - i;
        maxLen += groups[groupCount];
        groupCount++;
        i = j;
    }
    
    // dp[i][j] = number of ways to get length j using first i groups
    long long dp[1001][1001];
    memset(dp, 0, sizeof(dp));
    
    // Base case: 0 groups, 0 length = 1 way
    dp[0][0] = 1;
    
    // Fill DP table
    for (int idx = 1; idx <= groupCount; idx++) {
        int groupSize = groups[idx - 1];
        for (int j = 0; j <= maxLen; j++) {
            // Try all possible lengths for current group (at least 1)
            for (int length = 1; length <= min(groupSize, j); length++) {
                dp[idx][j] = (dp[idx][j] + dp[idx - 1][j - length]) % MOD;
            }
        }
    }
    
    // Sum all ways with length >= k
    long long result = 0;
    for (int j = k; j <= maxLen; j++) {
        result = (result + dp[groupCount][j]) % MOD;
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × k × max_group_size)

Three nested loops: groups × possible lengths × group sizes

⚠ Quadratic Growth

Space Complexity

O(n × k)

2D DP table with dimensions (number_of_groups × max_length)

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

234 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