Count The Repetitions

Count The Repetitions - Problem

We define a string str = [s, n] as the string str which consists of the string s concatenated n times.

For example, str = ["abc", 3] == "abcabcabc".

We define that string s1 can be obtained from string s2 if we can remove some characters from s2 such that it becomes s1.

For example, s1 = "abc" can be obtained from s2 = "adbec" by removing the characters 'd' and 'e'.

You are given two strings s1 and s2 and two integers n1 and n2. You have the two strings str1 = [s1, n1] and str2 = [s2, n2].

Return the maximum integer m such that str = [str2, m] can be obtained from str1.

Input & Output

Example 1 — Basic Case

$ Input: s1 = "acb", n1 = 4, s2 = "ab", n2 = 2

› Output: 2

💡 Note: str1 = "acbacbacbacb". We can form str2 = "ab" twice by taking characters at positions [0,2] and [3,5], so we can get [str2, 2] from str1.

Example 2 — No Complete Match

$ Input: s1 = "acb", n1 = 1, s2 = "acb", n2 = 1

› Output: 1

💡 Note: str1 = "acb" and we need s2 = "acb" once. We can form exactly 1 copy of s2 from str1.

Example 3 — Impossible Match

$ Input: s1 = "abc", n1 = 2, s2 = "def", n2 = 1

› Output: 0

💡 Note: str1 = "abcabc" contains no characters from s2 = "def", so we cannot form any copy of s2.

Constraints

1 ≤ s1.length, s2.length ≤ 100
1 ≤ n1, n2 ≤ 10⁶
s1 and s2 consist of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 8

The key insight is to detect repeating patterns instead of simulating every character match. The optimal approach uses cycle detection to find when the matching state repeats, allowing us to calculate the result efficiently without building the entire concatenated string. Time: O(|s1| × |s2|), Space: O(|s1|)

Common Approaches

✓ Math

⏱️ Time: N/A Space: N/A

Dfs

⏱️ Time: N/A Space: N/A

Brute Force Simulation

⏱️ Time: O(n1 × |s1| × n2 × |s2|) Space: O(n1 × |s1|)

Build str1 = s1*n1 and try to match as many complete copies of s2 as possible by scanning character by character. Stop when we can't complete another s2.

Pattern Detection with Cycle Finding

⏱️ Time: O(|s1| × |s2|) Space: O(|s1|)

Instead of building the entire str1, simulate matching process and detect when patterns repeat. Use the cycle to calculate results efficiently without full string construction.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_N 1000

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        base = (base * base) % mod;
        exp /= 2;
    }
    return result;
}

long long modInverse(long long a) {
    return modPow(a, MOD - 2, MOD);
}

int children[MAX_N][MAX_N];
int childCount[MAX_N];
long long fact[MAX_N + 1];

typedef struct {
    long long ways;
    int size;
} Result;

Result dfs(int node) {
    if (childCount[node] == 0) {
        Result r = {1, 1};
        return r;
    }
    
    long long result = 1;
    int subtreeSize = 0;
    int childSizes[MAX_N];
    int numChildren = 0;
    
    for (int i = 0; i < childCount[node]; i++) {
        Result childResult = dfs(children[node][i]);
        result = (result * childResult.ways) % MOD;
        childSizes[numChildren++] = childResult.size;
        subtreeSize += childResult.size;
    }
    
    if (subtreeSize > 0) {
        long long multinomial = fact[subtreeSize];
        for (int i = 0; i < numChildren; i++) {
            multinomial = (multinomial * modInverse(fact[childSizes[i]])) % MOD;
        }
        result = (result * multinomial) % MOD;
    }
    
    Result r = {result, subtreeSize + 1};
    return r;
}

int solution(int* prevRoom, int n) {
    if (n == 1) return 1;
    
    memset(childCount, 0, sizeof(childCount));
    
    for (int i = 1; i < n; i++) {
        children[prevRoom[i]][childCount[prevRoom[i]]++] = i;
    }
    
    fact[0] = 1;
    for (int i = 1; i <= n; i++) {
        fact[i] = (fact[i-1] * i) % MOD;
    }
    
    Result result = dfs(0);
    return result.ways;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int prevRoom[MAX_N];
    int n = 0;
    
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        prevRoom[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", solution(prevRoom, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.0K Views

Medium Frequency

~35 min Avg. Time

285 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