长度为K的子字符串的计数，具有精确的K个不同字符

在计算机科学中，给定一个字符串和一个整数 k，我们想要找出这个字符串中长度为 k 的子字符串中，恰好包含 k 个不同字符的子串数量。这个问题可以用很多种方法来解决，本文将介绍几种常见的解法。

解法一：暴力解法

暴力解法很简单粗暴，遍历每个长度为 k 的子字符串，然后检查它是否包含 k 个不同字符。如果符合条件，则将计数器加一。下面是暴力解法的 Python 代码实现：

def count_k_distinct_chars_substrings(s: str, k: int) -> int:
    count = 0
    for i in range(len(s) - k + 1):
        substring = s[i:i+k]
        distinct_chars = set(substring)
        if len(distinct_chars) == k:
            count += 1
    return count

这个算法的时间复杂度为 $O(nk)$，其中 n 为字符串长度。由于它非常简单，所以是一种比较容易理解和实现的解法，但是当字符串非常长且 k 较小的时候，它的性能会非常低下。

解法二：窗口滑动

窗口滑动算法是对暴力解法的一种优化。我们可以使用两个指针 start 和 end，分别指向当前窗口的起始位置和结束位置。我们可以使用一个 dist 变量来记录当前窗口中出现的不同字符的数量。我们可以向右移动 end 指针，如果出现了一个新的不同字符，那么我们将 dist 增加一。当 dist 达到 k 的时候，我们就找到了一个符合条件的子串，将计数器加一。此时我们可以向右移动 start 指针，同时将 dist 减一，直到 dist 小于 k。

这个算法的时间复杂度为 $O(n)$，相较于暴力解法而言，它的性能要好很多。下面是窗口滑动算法的 Python 代码实现：

def count_k_distinct_chars_substrings(s: str, k: int) -> int:
    count = 0
    dist = 0
    count_map = [0] * 26
    start = 0
    end = 0
    while end < len(s):
        count_map[ord(s[end]) - ord('a')] += 1
        if count_map[ord(s[end]) - ord('a')] == 1:
            dist += 1
        end += 1
        while dist == k:
            count += 1
            count_map[ord(s[start]) - ord('a')] -= 1
            if count_map[ord(s[start]) - ord('a')] == 0:
                dist -= 1
            start += 1
    return count

解法三：滑动窗口 + 位图

使用标准库中的 set 类型判断窗口中出现的字符的数量虽然很方便，但是它的性能并不是很好。我们可以使用位图来进行优化。对于一个只包含小写字母的字符串而言，我们可以使用一个整数变量（或者一个 bool 类型的数组）来表示出现过的字符。当我们遍历字符串时，我们可以使用一个 mask 变量来记录当前窗口中出现的字符。每当我们向右移动 end 指针时，我们将窗口内出现的字符位设置为 1。当 mask 的二进制表示中有 k 个 1 时，我们就找到了一个符合条件的子串，将计数器加一。此时我们可以向右移动 start 指针，同时将 mask 的二进制表示中对应位设置为 0，直到 mask 的二进制表示中只有 k-1 个 1。

下面是使用滑动窗口和位图来实现的 Python 代码：

def count_k_distinct_chars_substrings(s: str, k: int) -> int:
    count = 0
    count_map = 0
    start = 0
    end = 0
    while end < len(s):
        count_map |= (1 << (ord(s[end]) - ord('a')))
        if bin(count_map).count('1') == k:
            count += 1
        end += 1
        while bin(count_map).count('1') == k + 1:
            count_map &= ~(1 << (ord(s[start]) - ord('a')))
            start += 1
    return count

这个算法的时间复杂度也为 $O(n)$，但是相较于解法二而言，它的常数要更小一些。同时，这个算法的可扩展性也更好，可以适用于更大字符集的字符串。

总结

本文介绍了三种解法来解决长度为 k 的子字符串的计数，具有精确的 k 个不同字符的问题。最好的解法取决于具体的应用场景和字符串的特点。暴力解法在简单场景下表现不错，但是在字符串很长的时候性能不佳。滑动窗口算法需要使用 set 类型，对于非常大的字符集而言性能可能较低。滑动窗口 + 位图算法则可以快速处理大字符集的字符串。