Leetcode 1297：子串的最大出现次数（超详细的解法！！！）

给你一个字符串 s ，请你返回满足以下条件且出现次数最大的 任意 子串的出现次数：

• 子串中不同字母的数目必须小于等于 maxLetters 。
• 子串的长度必须大于等于 minSize 且小于等于 maxSize 。

示例 1：

输入：s = "aababcaab", maxLetters = 2, minSize = 3, maxSize = 4
输出：2
解释：子串 "aab" 在原字符串中出现了 2 次。
它满足所有的要求：2 个不同的字母，长度为 3 （在 minSize 和 maxSize 范围内）。

示例 2：

输入：s = "aaaa", maxLetters = 1, minSize = 3, maxSize = 3
输出：2
解释：子串 "aaa" 在原字符串中出现了 2 次，且它们有重叠部分。

示例 3：

输入：s = "aabcabcab", maxLetters = 2, minSize = 2, maxSize = 3
输出：3

示例 4：

输入：s = "abcde", maxLetters = 2, minSize = 3, maxSize = 3
输出：0

提示：

• 1 <= s.length <= 10^5
• 1 <= maxLetters <= 26
• 1 <= minSize <= maxSize <= min(26, s.length)
• s 只包含小写英文字母。

解题思路

这个问题首先不难想到暴力解法，也就对于字符串s中的每个元素c，我们分别以c作为左边界，然后判断其后长度在[minSize,maxSize]区间中的字符串是不是满足字母数小于等于maxLetters（使用set去除重复字符）。

class Solution:
    def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> int:
        cnt = collections.Counter()
        res = 0
        for i in range(len(s) - minSize + 1):
            for k in range(minSize, maxSize + 1):
                if i + k <= len(s):
                    if len(set(s[i:i+k])) <= maxLetters:
                        cnt[s[i:i+k]] += 1
                        res = max(res, cnt[s[i:i+k]])
        return res

但是这么做就超时了。实际上这个问题有一个性质，那就是对于长度为minSize的字符串来说，如果其满足条件，那么比其长的字符串都满足条件，所以我们只需要统计minSize长度的字符串即可。

class Solution:
    def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> int:
        cnt = collections.Counter()
        res = 0
        for i in range(len(s) - minSize + 1):
            if i + minSize <= len(s):
                if len(set(s[i:i+minSize])) <= maxLetters:
                    cnt[s[i:i+minSize]] += 1
                    res = max(res, cnt[s[i:i+minSize]])
        return res

这个问题的算法思路至此结束。接下来讨论的就是具体实现上的问题，在上面的实现中，我们针对所有长度为minSize的字串都进行了set的求解，这是非常低效的。我们实现上可以先统计长度为minSize的字符串的出现次数，然后针对出现次数最多的字符串判断其是否满足条件，如果不满足条件，那么求出现次数比之小的下一个字符串是否满足条件，以此类推。

class Solution:
    def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> int:
        cnt = collections.Counter([s[i:i + minSize] for i in range(len(s) - minSize + 1)])
        for k, v in cnt.most_common():
            if len(set(k)) <= maxLetters:
                return v
        return 0

这是一种优化思路，但是这种策略需要枚举所有长度为minSize的字符串，所以空间复杂度很高。另一种策略就是优化set，我们可以通过滑动窗口的方式维护窗口大小为minSize的区间内字符个数。

class Solution:
    def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> int:
        nq = res = 0
        chs = collections.Counter()
        cnt = collections.Counter()
        
        for r in range(len(s)):
            if chs[s[r]] == 0:
                nq += 1
            chs[s[r]] += 1
                
            if minSize <= r:
                chs[s[r - minSize]] -= 1
                if chs[s[r - minSize]] == 0:
                    nq -= 1
                    
            if minSize - 1 <= r and nq <= maxLetters:
                cnt[s[r-minSize+1:r+1]] += 1
                res = max(res, cnt[s[r-minSize+1:r+1]])
        return res

我将该问题的其他语言版本添加到了我的GitHub Leetcode

如有问题，希望大家指出！！！