466. Count The Repetitions

Description

We define 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 = "abdbec" based on our definition by removing the bolded underlined characters.

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.

 

Example 1:

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

Example 2:

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

 

Constraints:

• 1 <= s1.length, s2.length <= 100
• s1 and s2 consist of lowercase English letters.
• 1 <= n1, n2 <= 106

Solutions

Solution 1: Preprocessing + Iteration

We preprocess the string \(s_2\) such that for each starting position \(i\), we calculate the next position \(j\) and the count of \(s_2\) after matching a complete \(s_1\), i.e., \(d[i] = (cnt, j)\), where \(cnt\) represents the count of \(s_2\), and \(j\) represents the next position in the string \(s_2\).

Next, we initialize \(j=0\), and then loop \(n1\) times. Each time, we add \(d[j][0]\) to the answer, and then update \(j=d[j][1]\).

The final answer is the count of \(s_2\) that can be matched by \(n1\) \(s_1\), divided by \(n2\).

The time complexity is \(O(m \times n + n_1)\), and the space complexity is \(O(n)\). Where \(m\) and \(n\) are the lengths of \(s_1\) and \(s_2\) respectively.

Python3JavaC++GoTypeScript

class Solution:
    def getMaxRepetitions(self, s1: str, n1: int, s2: str, n2: int) -> int:
        n = len(s2)
        d = {}
        for i in range(n):
            cnt = 0
            j = i
            for c in s1:
                if c == s2[j]:
                    j += 1
                if j == n:
                    cnt += 1
                    j = 0
            d[i] = (cnt, j)

        ans = 0
        j = 0
        for _ in range(n1):
            cnt, j = d[j]
            ans += cnt
        return ans // n2

class Solution {
    public int getMaxRepetitions(String s1, int n1, String s2, int n2) {
        int m = s1.length(), n = s2.length();
        int[][] d = new int[n][0];
        for (int i = 0; i < n; ++i) {
            int j = i;
            int cnt = 0;
            for (int k = 0; k < m; ++k) {
                if (s1.charAt(k) == s2.charAt(j)) {
                    if (++j == n) {
                        j = 0;
                        ++cnt;
                    }
                }
            }
            d[i] = new int[] {cnt, j};
        }
        int ans = 0;
        for (int j = 0; n1 > 0; --n1) {
            ans += d[j][0];
            j = d[j][1];
        }
        return ans / n2;
    }
}

class Solution {
public:
    int getMaxRepetitions(string s1, int n1, string s2, int n2) {
        int m = s1.size(), n = s2.size();
        vector<pair<int, int>> d;
        for (int i = 0; i < n; ++i) {
            int j = i;
            int cnt = 0;
            for (int k = 0; k < m; ++k) {
                if (s1[k] == s2[j]) {
                    if (++j == n) {
                        ++cnt;
                        j = 0;
                    }
                }
            }
            d.emplace_back(cnt, j);
        }
        int ans = 0;
        for (int j = 0; n1; --n1) {
            ans += d[j].first;
            j = d[j].second;
        }
        return ans / n2;
    }
};

func getMaxRepetitions(s1 string, n1 int, s2 string, n2 int) (ans int) {
    n := len(s2)
    d := make([][2]int, n)
    for i := 0; i < n; i++ {
        j := i
        cnt := 0
        for k := range s1 {
            if s1[k] == s2[j] {
                j++
                if j == n {
                    cnt++
                    j = 0
                }
            }
        }
        d[i] = [2]int{cnt, j}
    }
    for j := 0; n1 > 0; n1-- {
        ans += d[j][0]
        j = d[j][1]
    }
    ans /= n2
    return
}

function getMaxRepetitions(s1: string, n1: number, s2: string, n2: number): number {
    const n = s2.length;
    const d: number[][] = new Array(n).fill(0).map(() => new Array(2).fill(0));
    for (let i = 0; i < n; ++i) {
        let j = i;
        let cnt = 0;
        for (const c of s1) {
            if (c === s2[j]) {
                if (++j === n) {
                    j = 0;
                    ++cnt;
                }
            }
        }
        d[i] = [cnt, j];
    }
    let ans = 0;
    for (let j = 0; n1 > 0; --n1) {
        ans += d[j][0];
        j = d[j][1];
    }
    return Math.floor(ans / n2);
}

Comments