【无标题】

题目描述

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

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

示例1：

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

示例2：

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

示例3：

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

提示：

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

题目链接

题目难度——简单

方法一：枚举

  题目的提示里说的长度都比较小，所以我们可以直接枚举，用python的话更方便，用C++的话有一点复杂。记sequence的长度为m，word的长度为n，我们可以直接从k = m/n开始，每次减一，判断word * k是否是sequence的子串，是就返回k，否则直到最后，不是子串，返回0。对于C++，也可以这样，不过要麻烦一点。写法上也有点区别。

代码/Python

class Solution:
    def maxRepeating(self, sequence: str, word: str) -> int:
        times = len(sequence) // len(word)
        for k in range(times, 0, -1):
            if word * k in sequence:
                return k
        return 0
1
2
3
4
5
6
7

class Solution {
public:
    int maxRepeating(string sequence, string word) {
        int seq_len, word_len, i, k, times;
        string tmp;
        seq_len = sequence.size();
        word_len = word.size();
        times = seq_len / word_len;
        auto repeat = [] (string s, int time) -> string {string res; for(int i = 0; i < time; i++)res += s; return res;};
        for(k = times; k > 0; k--){
            for(i = 0; i <= seq_len - word_len * k; i++){
                tmp = sequence.substr(i, k * word_len);
                string rep = repeat(word, k);
                if(tmp == rep){
                    return k;
                }
            }
        }
        return 0;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

C++这里因为不能直接用像python那样word * k的语法，所以用了一个lambda表达式来间接实现重复n次这一操作，可能这就有点耗时了，24ms，挺慢的。看看能不能优化：不用lambda，直接在外层循环体里每次先生成那个重复字串。

class Solution {
public:
    int maxRepeating(string sequence, string word) {
        int seq_len, word_len, i, k, times;
        string tmp, rep;
        seq_len = sequence.size();
        word_len = word.size();
        times = seq_len / word_len;
        //auto repeat = [] (string s, int time) -> string {string res; for(int i = 0; i < time; i++)res += s; return res;};
        for(k = times; k > 0; k--){
            rep = "";
            for(int i = 0; i < k; i++) rep += word;
            for(i = 0; i <= seq_len - word_len * k; i++){
                tmp = sequence.substr(i, k * word_len);
                if(tmp == rep){
                    return k;
                }
            }
        }
        return 0;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

用时直接快了一倍，说明改动还是有效果的，虽然只击败了30%不到，但看了看用时前面的，都是用的内置函数，当然挺快的。

总结

  最坏情况下要一直判断到最后k等于1的情况，所以最坏的话时间是O(N^2)，只用到了常量空间，所以空间是O(1)。