Total Characters in String After Transformations II

Total Characters in String After Transformations II - Problem

Transform and Count: The Expanding String Challenge

Imagine you have a magical string where each character can multiply into multiple consecutive letters! Given a string s of lowercase English letters, you need to perform exactly t transformations and count the final length.

🔄 Transformation Rules:
• Each character s[i] is replaced by the next nums[s[i] - 'a'] consecutive characters in the alphabet
• The alphabet wraps around: after 'z' comes 'a'

📝 Examples:
• If s[i] = 'a' and nums[0] = 3, then 'a' becomes "bcd"
• If s[i] = 'y' and nums[24] = 3, then 'y' becomes "zab" (wrapping around)

🎯 Goal: Return the length of the string after exactly t transformations, modulo 10⁹ + 7.

This is a challenging problem that combines string manipulation, mathematical optimization, and dynamic programming concepts!

Input & Output

example_1.py — Basic Transformation

$ Input: s = "ab", t = 1, nums = [1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]

› Output: 3

💡 Note: After 1 transformation: 'a' becomes 'b' (nums[0]=1), 'b' becomes 'cd' (nums[1]=2). Result: "b" + "cd" = "bcd" with length 3.

example_2.py — Multiple Transformations

$ Input: s = "a", t = 2, nums = [2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]

› Output: 2

💡 Note: T1: 'a'→'bc' (nums[0]=2). T2: 'b'→'c' (nums[1]=1), 'c'→'d' (nums[2]=1). Final: "cd", length=2.

example_3.py — Wrapping Around

$ Input: s = "z", t = 1, nums = [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3]

› Output: 3

💡 Note: After 1 transformation: 'z' becomes the next 3 characters, which wraps around: 'z'→'abc' (since after z comes a). Final string: "abc" with length 3.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters
1 ≤ t ≤ 10⁹
nums.length == 26
1 ≤ nums[i] ≤ 3
Result must be returned modulo 10⁹ + 7

Visualization

Tap to expand

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

This problem requires matrix exponentiation for optimal performance. The key insight is to track character counts instead of building actual strings. Use a 26×26 transformation matrix to represent how each character expands, then compute M^t efficiently in O(26³ log t) time using binary exponentiation.

Common Approaches

✓ Matrix Exponentiation (Optimal)

⏱️ Time: O(26³ log t + |s|) Space: O(26²)

Instead of simulating string transformations, we track the count of each character (a-z) and use matrix exponentiation to compute how these counts evolve after t transformations. This avoids the exponential growth problem.

Matrix Exponentiation (Optimal) — Algorithm Steps

Count initial character frequencies in string s
Build transformation matrix M where M[i][j] represents how character i contributes to character j
Use matrix exponentiation to compute M^t efficiently in O(log t) operations
Apply M^t to initial character count vector
Sum all character counts to get final string length

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Characters

Count frequency of each character in input string

Build Matrix

Create transformation matrix showing character mappings

Matrix Power

Use exponentiation to compute M^t efficiently

Apply & Sum

Apply final matrix to counts and sum total

Code -

solution.c — C

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

#define MOD 1000000007

// Static arrays to avoid stack overflow
static long long tempMatrix[26][26];
static long long count[26];
static long long trans[26][26];
static long long finalTrans[26][26];
static long long resultCount[26];

// Matrix multiplication
void matrixMult(long long A[26][26], long long B[26][26], long long result[26][26]) {
    for (int i = 0; i < 26; i++) {
        for (int j = 0; j < 26; j++) {
            tempMatrix[i][j] = 0;
            for (int k = 0; k < 26; k++) {
                tempMatrix[i][j] = (tempMatrix[i][j] + (A[i][k] * B[k][j]) % MOD) % MOD;
            }
        }
    }
    
    for (int i = 0; i < 26; i++) {
        for (int j = 0; j < 26; j++) {
            result[i][j] = tempMatrix[i][j];
        }
    }
}

// Matrix exponentiation
void matrixPower(long long matrix[26][26], int power, long long result[26][26]) {
    if (power == 0) {
        for (int i = 0; i < 26; i++) {
            for (int j = 0; j < 26; j++) {
                result[i][j] = (i == j) ? 1 : 0;
            }
        }
        return;
    }
    
    // Initialize result as identity
    for (int i = 0; i < 26; i++) {
        for (int j = 0; j < 26; j++) {
            result[i][j] = (i == j) ? 1 : 0;
        }
    }
    
    // Copy matrix to base
    long long base[26][26];
    for (int i = 0; i < 26; i++) {
        for (int j = 0; j < 26; j++) {
            base[i][j] = matrix[i][j];
        }
    }
    
    while (power > 0) {
        if (power % 2 == 1) {
            matrixMult(result, base, result);
        }
        matrixMult(base, base, base);
        power /= 2;
    }
}

int lengthAfterTransformations(char* s, int t, int* nums) {
    // Handle edge case
    if (t == 0) {
        return strlen(s);
    }
    
    // Count initial character frequencies
    memset(count, 0, sizeof(count));
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        count[s[i] - 'a']++;
    }
    
    // Build transformation matrix
    memset(trans, 0, sizeof(trans));
    for (int i = 0; i < 26; i++) {
        int expand = nums[i];
        for (int j = 0; j < expand; j++) {
            int nextChar = (i + 1 + j) % 26;
            trans[i][nextChar] += 1;  // FIX: += instead of =
        }
    }
    
    // Get M^t
    matrixPower(trans, t, finalTrans);
    
    // Apply transformation to initial counts
    memset(resultCount, 0, sizeof(resultCount));
    for (int i = 0; i < 26; i++) {
        if (count[i] > 0) {
            for (int j = 0; j < 26; j++) {
                resultCount[j] = (resultCount[j] + (count[i] * finalTrans[i][j]) % MOD) % MOD;
            }
        }
    }
    
    // Calculate final sum
    long long total = 0;
    for (int i = 0; i < 26; i++) {
        total = (total + resultCount[i]) % MOD;
    }
    
    return (int) total;
}

int main() {
    char s[1001];
    int t;
    char numsLine[1000];
    int nums[26];
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;  // Remove newline
    
    scanf("%d", &t);
    getchar();  // consume newline
    
    fgets(numsLine, sizeof(numsLine), stdin);
    numsLine[strcspn(numsLine, "\n")] = 0;  // Remove newline
    
    // Parse comma-separated numbers
    int numCount = 0;
    char* token = strtok(numsLine, ",");
    while (token != NULL && numCount < 26) {
        nums[numCount++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    int result = lengthAfterTransformations(s, t, nums);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(26³ log t + |s|)

Matrix exponentiation takes O(26³ log t) and initial counting takes O(|s|)

⚡ Linearithmic

Space Complexity

O(26²)

Need to store 26×26 transformation matrix and character count arrays

✓ Linear Space

27.5K Views

Medium-High Frequency

~35 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

Matrix Exponentiation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler