# 1668. 最大重复子字符串

### Link

{% embed url="<https://leetcode.cn/problems/maximum-repeating-substring/>" %}

### Problem

给你一个字符串 sequence ，如果字符串 word 连续重复 k 次形成的字符串是 sequence 的一个子字符串，那么单词 word 的 重复值为 k 。单词 word 的 最大重复值 是单词 word 在 sequence 中最大的重复值。如果 word 不是 sequence 的子串，那么重复值 k 为 0 。

给你一个字符串 sequence 和 word ，请你返回 最大重复值 k 。

示例 1：

{% code overflow="wrap" %}

```
输入：sequence = "ababc", word = "ab"
输出：2
解释："abab" 是 "ababc" 的子字符串。
```

{% endcode %}

示例2：

{% code overflow="wrap" %}

```
输入：sequence = "ababc", word = "ba"
输出：1
解释："ba" 是 "ababc" 的子字符串，但 "baba" 不是 "ababc" 的子字符串。
```

{% endcode %}

示例3:

{% code overflow="wrap" %}

```
输入：sequence = "ababc", word = "ac"
输出：0
解释："ac" 不是 "ababc" 的子字符串。
```

{% endcode %}

提示：

* `1 <= sequence.length <= 100`
* `1 <= word.length <= 100`
* `sequence` 和 `word` 都只包含小写英文字母。

### Solution

#### KMP 算法

{% tabs %}
{% tab title="Go" %}

```go
func maxRepeating(sequence string, word string) int {
    n, m := len(sequence), len(word)
    if n < m {
        return 0
    }
    //get fail arr
    fail := make([]int, m)
    fail[0] = -1
    for i, j := 1, -1; i < m ; i++ {
        for j != -1 && word[i] != word[j+1] {
            j = fail[j]
        }
        if word[i] == word[j+1] {
            j++
        }
        fail[i] = j
    }

    //match pattern
    dp, max := make([]int, n), 0
    for i, j := 0, -1; i < n; i++ {
        for j != -1 && sequence[i] != word[j+1] {
            j = fail[j]
        }
        if sequence[i] == word[j+1] {
            j++
            if j == m-1 {
                if i < m {
                    dp[i] = 1
                } else {
                    dp[i] = dp[i-m] + 1
                }
                if dp[i] > max {
                    max = dp[i]
                }
                j = fail[j]
            }
        }
    }
    return max
}
```

{% endtab %}

{% tab title="C++" %}

<pre class="language-cpp"><code class="lang-cpp"><strong>
</strong></code></pre>

{% endtab %}
{% endtabs %}

#### 动态规划

{% tabs %}
{% tab title="Go" %}

```go
func maxRepeating(sequence string, word string) int {
    m, n := len(sequence), len(word)
    if m < n {
        return 0
    }
    dp, max := make([]int, m), 0
    if sequence[0:n] == word {
        dp[n-1] = 1
        max = 1
    }
    for i := n; i < m; i++ {
        if sequence[i-n+1:i+1] == word {
            dp[i] = dp[i-n] + 1
        }
        if dp[i] > max {
            max = dp[i]
        }
    }
    return max
}
```

{% endtab %}

{% tab title="C++" %}

{% endtab %}
{% endtabs %}