检查是否存在仅包含 2 个不同字符且频率为其他字符两倍的子字符串

在编写代码时，我们有时需要检查字符串中是否存在仅包含 2 个不同字符且频率为其他字符两倍的子字符串。例如，对于字符串 "abbcdc"，它包含子字符串 "bb"，其中字符 "b" 的频率为其他字符 "c" 和 "d" 的频率的两倍。本文将介绍一些实现方法，帮助程序员检查此类字符串。

方法一：暴力搜索

最直接的方法是暴力搜索所有可能的子字符串，并检查它们是否符合要求。可以使用两个嵌套循环来枚举所有的子字符串，并使用一个哈希表来计算每个字符的出现次数。

def contains_twice_freq_substring(s: str) -> bool:
    n = len(s)
    for i in range(n):
        for j in range(i+2, n+1):
            freq = {}
            for c in s[i:j]:
                freq[c] = freq.get(c, 0) + 1
            unique_chars = len(freq)
            if unique_chars == 2 and 2 * min(freq.values()) == max(freq.values()):
                return True
    return False

这个算法的时间复杂度为 $O(n^3)$，其中 $n$ 是字符串的长度。不过，如果字符串中只有很少的符合条件的子字符串，那么算法的实际效率可能会比较高。

方法二：滑动窗口

我们可以使用滑动窗口来优化上述算法。设置两个指针 $i$ 和 $j$，分别指向子字符串的左右边界。初始时，两个指针都指向字符串的起始位置。然后，我们可以依次移动右指针 $j$，并将新的字符加入到哈希表中，同时检查当前的子字符串是否符合条件。如果符合条件，我们可以更新结果并继续向右移动左指针 $i$，直到子字符串不再符合条件。在这个过程中，我们可以维护一个哈希表，记录当前子字符串中各字符出现的次数。

def contains_twice_freq_substring(s: str) -> bool:
    freq = {}
    i = j = 0
    while j < len(s):
        if s[j] not in freq:
            freq[s[j]] = 0
        freq[s[j]] += 1
        while len(freq) > 2 or 2 * min(freq.values()) < max(freq.values()):
            freq[s[i]] -= 1
            if freq[s[i]] == 0:
                del freq[s[i]]
            i += 1
        if len(freq) == 2 and 2 * min(freq.values()) == max(freq.values()):
            return True
        j += 1
    return False

这个算法的时间复杂度为 $O(n)$，其中 $n$ 是字符串的长度。

方法三：位运算

我们可以用位运算来实现一个非常快速的算法。设置两个二进制数 $x$ 和 $y$，分别用来记录字符串中出现次数最多的字符的位图和次多的字符的位图。假设我们当前正在处理一个字符 $c$，如果 $c$ 是字符串中出现次数最多的字符之一，那么我们就将对应的位设为 $1$。如果 $c$ 是字符串中出现次数次多的字符之一，那么我们就将对应的位设为 $-1$。然后，我们可以检查当前的子字符串是否符合条件。如果符合条件，我们可以更新结果，并继续向右移动左指针 $i$，直到子字符串不再符合条件。

def contains_twice_freq_substring(s: str) -> bool:
    x = y = ans = 0
    for c in s:
        if x & (1 << ord(c)):
            y |= 1 << ord(c)
        else:
            x |= 1 << ord(c)
            y &= ~(1 << ord(c))
        if bin(x).count('1') == 2 and y == x >> 1:
            ans = 1
        if ans == 1 and y:
            return True
    return False

这个算法的时间复杂度为 $O(n)$，其中 $n$ 是字符串的长度。