Minimum Time to Revert Word to Initial State II

Minimum Time to Revert Word to Initial State II - Problem

Transform and Restore: You're given a string word and an integer k. Every second, you must perform two operations: remove the first k characters from the word, then add any k characters to the end. The key insight is that you can choose what characters to add - they don't have to be the same ones you removed!

Your goal is to find the minimum time greater than zero required to make the word identical to its original state. This is essentially asking: what's the smallest number of operations needed before we can restore the word by choosing the right characters to append?

Example: If word = "abcdef" and k = 2, after removing "ab" we have "cdef". We need to add 2 characters to make it potentially restorable to "abcdef".

Input & Output

basic_example.py — Python

$ Input: word = "abacaba", k = 3

› Output: 2

💡 Note: After 1 operation: remove 'aba' → remaining 'caba'. Since 'abacaba' doesn't start with 'caba', we can't restore yet. After 2 operations: remove 'cab' → remaining 'a'. Since 'abacaba' starts with 'a', we can restore by adding 'bacaba' to get 'abacaba'. Answer: 2.

simple_case.py — Python

$ Input: word = "abcdef", k = 2

› Output: 3

💡 Note: After 1 operation: 'cdef' remains. 'abcdef' doesn't start with 'cdef'. After 2 operations: 'ef' remains. 'abcdef' doesn't start with 'ef'. After 3 operations: empty string remains. We can always restore from empty, so answer is 3.

repeating_pattern.py — Python

$ Input: word = "abababab", k = 2

› Output: 1

💡 Note: After 1 operation: remove 'ab' → remaining 'ababab'. Since 'abababab' starts with 'ababab', we can restore by adding 'ab' at the end. Answer: 1.

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Start with word 'abacaba' and k=3. We need to find when remaining suffix matches word prefix.

First Operation

Remove 'aba' → remaining 'caba'. Check: does 'abacaba' start with 'caba'? No.

Second Operation

Remove 'cab' → remaining 'a'. Check: does 'abacaba' start with 'a'? Yes!

Restoration

Since suffix 'a' matches prefix 'a', we can add 'bacaba' to restore the original word.

Key Takeaway

🎯 Key Insight: Use the Z-algorithm to precompute suffix-prefix matches in O(n) time, then check only positions that are multiples of k for optimal efficiency.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to compute Z-array, then O(n/k) checks in O(1) each

✓ Linear Growth

Space Complexity

O(n)

Space for Z-array or hash values

⚡ Linearithmic Space

Constraints

1 ≤ word.length ≤ 10⁶
1 ≤ k ≤ word.length
word consists only of lowercase English letters
Time limit: Must handle large inputs efficiently

Asked in

G Google 25 ⊞ Microsoft 18 a Amazon 12 f Meta 8

The optimal approach uses the Z-algorithm to efficiently find suffix-prefix matches in O(n) time. Key insight: the word can be restored at time t if the remaining suffix after removing t*k characters matches a prefix of the original word. The Z-algorithm precomputes this information, allowing O(1) checks at each candidate position.

Common Approaches

Approach	Time	Space	Notes
✓ Rolling Hash Optimization	O(n)	O(n)	Use rolling hash to efficiently check suffix-prefix matches
Brute Force Simulation	O(n²)	O(1)	Simulate each time step and check if word can be restored

Rolling Hash Optimization — Algorithm Steps

Compute Z-array or use rolling hash for the word
For each position i that is a multiple of k, check if word[i:] matches word[0:]
Use precomputed hash values to do this in O(1) time
Return the first valid position divided by k
This avoids repeated string comparisons

Visualization

Tap to expand

Step-by-Step Walkthrough

Compute Z-array

Build Z-array showing longest prefix match at each position

Check Multiples of k

Only examine positions that are multiples of k

O(1) Match Check

Use Z-value to instantly check if suffix matches prefix

Return First Match

Return the first valid restoration time

Code -

solution.c — C

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

void computeZArray(char* s, int* z, int n) {
    int l = 0, r = 0;
    
    for (int i = 1; i < n; i++) {
        if (i <= r) {
            z[i] = (r - i + 1 < z[i - l]) ? r - i + 1 : z[i - l];
        }
        
        while (i + z[i] < n && s[z[i]] == s[i + z[i]]) {
            z[i]++;
        }
        
        if (i + z[i] - 1 > r) {
            l = i;
            r = i + z[i] - 1;
        }
    }
}

int minimumTimeToInitialState(char* word, int k) {
    int n = strlen(word);
    int* z = (int*)calloc(n, sizeof(int));
    
    // Compute Z-array for efficient prefix matching
    computeZArray(word, z, n);
    
    // Check each multiple of k
    for (int i = k; i < n; i += k) {
        // If suffix starting at i matches prefix
        if (z[i] >= n - i) {
            free(z);
            return i / k;
        }
    }
    
    // If no match found, we need to remove all characters
    free(z);
    return (n + k - 1) / k;
}

int main() {
    char word[100001];
    int k;
    fgets(word, sizeof(word), stdin);
    word[strcspn(word, "\n")] = 0;
    // Remove quotes
    if (word[0] == '"') {
        memmove(word, word + 1, strlen(word));
    }
    if (word[strlen(word) - 1] == '"') {
        word[strlen(word) - 1] = 0;
    }
    scanf("%d", &k);
    printf("%d\n", minimumTimeToInitialState(word, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to compute Z-array, then O(n/k) checks in O(1) each

✓ Linear Growth

Space Complexity

O(n)

Space for Z-array or hash values

⚡ Linearithmic Space

Constraints

1 ≤ word.length ≤ 10⁶
1 ≤ k ≤ word.length
word consists only of lowercase English letters
Time limit: Must handle large inputs efficiently

41.0K Views

Medium Frequency

~25 min Avg. Time

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

Rolling Hash Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler