String Transformation

String Transformation - Problem

You are given two strings s and t of equal length n. You can perform the following operation on the string s:

Remove a suffix of s of length l where 0 < l < n and append it at the start of s.

For example, let s = 'abcd' then in one operation you can remove the suffix 'cd' and append it in front of s making s = 'cdab'.

You are also given an integer k. Return the number of ways in which s can be transformed into t in exactly k operations.

Since the answer can be large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Transformation

$ Input: s = "abcd", t = "cdab", k = 1

› Output: 1

💡 Note: Remove suffix "cd" (length 2) and append to front: "abcd" → "cdab". There's exactly 1 way to transform s to t in 1 operation.

Example 2 — Multiple Operations

$ Input: s = "abc", t = "bca", k = 2

› Output: 1

💡 Note: One possible path: "abc" → remove "c" → "cab" → remove "ab" → "bca". Need to count all paths with exactly 2 operations.

Example 3 — Impossible Target

$ Input: s = "abc", t = "xyz", k = 1

› Output: 0

💡 Note: Target "xyz" is not a rotation of "abc", so it's impossible to reach regardless of operations.

Constraints

2 ≤ s.length ≤ 1000
t.length = s.length
1 ≤ k ≤ 1000
s and t consist of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 32 a Amazon 28

The key insight is recognizing that each operation creates a rotation of the original string. The best approach uses dynamic programming with rotation indices to efficiently count transformation paths. Time: O(n² × k), Space: O(n × k).

Common Approaches

✓ Dynamic Programming with Rotation Index

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

Recognize that each operation creates a rotation of the original string. Pre-compute all possible rotations and use a 2D DP table where dp[rotation][operations] stores the number of ways to reach each rotation in exactly that many operations.

Memoized Recursion

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

Same recursive approach as brute force but stores results in a memo table. When we encounter the same string with the same number of operations left, we return the cached result instead of recomputing.

Recursive Brute Force

⏱️ Time: O((n-1)^k) Space: O(k)

For each operation, try removing every possible suffix (length 1 to n-1) and recursively count ways to reach target in remaining operations. Uses backtracking to explore all paths.

Dynamic Programming with Rotation Index — Algorithm Steps

Generate all n possible rotations of string s
Find which rotation matches target t
Use DP: dp[i][j] = ways to reach rotation i in j operations
Fill DP table: each rotation can come from n-1 previous rotations

Visualization

Tap to expand

Step-by-Step Walkthrough

Map Rotations

Index all possible rotations of string s

Fill DP Table

dp[rotation][ops] = ways to reach rotation in ops steps

Find Answer

Return dp[target_rotation][k]

Code -

solution.c — C

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

#define MOD 1000000007

static long long dp[1000][1001];

long long solution(char* s, char* t, int k) {
    int n = strlen(s);
    
    // Generate all rotations of s
    char rotations[1000][1001];
    for (int i = 0; i < n; i++) {
        strcpy(rotations[i], s + i);
        strncat(rotations[i], s, i);
    }
    
    // Find all target rotation indices (there might be duplicates)
    int targetIndices[1000];
    int targetCount = 0;
    for (int i = 0; i < n; i++) {
        if (strcmp(rotations[i], t) == 0) {
            targetIndices[targetCount++] = i;
        }
    }
    
    if (targetCount == 0) {
        return 0; // Target not reachable
    }
    
    // Initialize DP table
    memset(dp, 0, sizeof(dp));
    dp[0][0] = 1; // Start with original string (rotation 0)
    
    // Fill DP table
    for (int ops = 0; ops < k; ops++) {
        for (int currRot = 0; currRot < n; currRot++) {
            if (dp[currRot][ops] == 0) continue;
            
            // Try all possible suffix operations
            for (int suffixLen = 1; suffixLen < n; suffixLen++) {
                // Calculate which rotation we get
                int nextRot = (currRot + suffixLen) % n;
                dp[nextRot][ops + 1] = (dp[nextRot][ops + 1] + dp[currRot][ops]) % MOD;
            }
        }
    }
    
    // Sum up ways to reach any target rotation index
    long long result = 0;
    for (int i = 0; i < targetCount; i++) {
        result = (result + dp[targetIndices[i]][k]) % MOD;
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n² × k)

DP table is n×k, each cell computed from n-1 transitions

✓ Linear Growth

Space Complexity

O(n × k)

DP table stores n rotations × k operations

⚡ Linearithmic Space

23.4K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming with Rotation Index — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler