统计一个字符串的 k 子序列美丽值最大的数目

标签: 贪心 哈希表 数学 字符串 组合数学

难度: Hard

给你一个字符串 s 和一个整数 k 。

k 子序列指的是 s 的一个长度为 k 的 子序列 ,且所有字符都是 唯一 的,也就是说每个字符在子序列里只出现过一次。

定义 f(c) 为字符 c 在 s 中出现的次数。

k 子序列的 美丽值 定义为这个子序列中每一个字符 c 的 f(c) 之  。

比方说,s = "abbbdd" 和 k = 2 ,我们有:

  • f('a') = 1, f('b') = 3, f('d') = 2
  • s 的部分 k 子序列为:
    • "abbbdd" -> "ab" ,美丽值为 f('a') + f('b') = 4
    • "abbbdd" -> "ad" ,美丽值为 f('a') + f('d') = 3
    • "abbbdd" -> "bd" ,美丽值为 f('b') + f('d') = 5

请你返回一个整数,表示所有 k 子序列 里面 美丽值 是 最大值 的子序列数目。由于答案可能很大,将结果对 109 + 7 取余后返回。

一个字符串的子序列指的是从原字符串里面删除一些字符(也可能一个字符也不删除),不改变剩下字符顺序连接得到的新字符串。

注意:

  • f(c) 指的是字符 c 在字符串 s 的出现次数,不是在 k 子序列里的出现次数。
  • 两个 k 子序列如果有任何一个字符在原字符串中的下标不同,则它们是两个不同的子序列。所以两个不同的 k 子序列可能产生相同的字符串。

示例 1:

输入:s = "bcca", k = 2
输出:4
解释:s 中我们有 f('a') = 1 ,f('b') = 1 和 f('c') = 2 。
s 的 k 子序列为:
bcca ,美丽值为 f('b') + f('c') = 3
bcca ,美丽值为 f('b') + f('c') = 3
bcca ,美丽值为 f('b') + f('a') = 2
bcca ,美丽值为 f('c') + f('a') = 3
bcca ,美丽值为 f('c') + f('a') = 3
总共有 4 个 k 子序列美丽值为最大值 3 。
所以答案为 4 。

示例 2:

输入:s = "abbcd", k = 4
输出:2
解释:s 中我们有 f('a') = 1 ,f('b') = 2 ,f('c') = 1 和 f('d') = 1 。
s 的 k 子序列为:
abbcd ,美丽值为 f('a') + f('b') + f('c') + f('d') = 5
abbcd ,美丽值为 f('a') + f('b') + f('c') + f('d') = 5 
总共有 2 个 k 子序列美丽值为最大值 5 。
所以答案为 2 。

提示:

  • 1 <= s.length <= 2 * 105
  • 1 <= k <= s.length
  • s 只包含小写英文字母。

Submission

运行时间: 72 ms

内存: 17.0 MB

class Solution:
    def countKSubsequencesWithMaxBeauty(self, s: str, k: int) -> int:
        mod = 10**9 + 7
        cnt = Counter(Counter(s).values())

        ans = 1
        for c,num in sorted(cnt.items(),reverse = True):
            if num >= k:
                return ans * pow(c,k,mod) * comb(num,k) % mod
            ans = ans * pow(c,num,mod) % mod
            k -= num
        return 0
        

Explain

这个题解首先通过计算每个字符在字符串中的出现次数,然后进一步统计每个出现次数的字符有多少个。接着,从出现次数最高的字符开始,尝试构建长度为k的子序列,计算其美丽值。如果某个出现次数的字符数量足以构成长度k的子序列,那么直接计算该子序列的美丽值并返回。如果不足以构成长度k,就将这些字符的美丽值加入总和,并减少k的值,继续寻找下一组出现次数较多的字符。这种方法保证了在满足子序列长度为k的条件下,尽可能地使用出现次数高的字符,从而最大化子序列的美丽值。

时间复杂度: O(u log u) 其中 u 是不同出现次数的数量

空间复杂度: O(u) 其中 u 是不同出现次数的数量

class Solution:
    def countKSubsequencesWithMaxBeauty(self, s: str, k: int) -> int:
        mod = 10**9 + 7  # 定义模数
        cnt = Counter(Counter(s).values())  # 首先计算每个字符的出现次数,然后统计每个出现次数的字符数量

        ans = 1  # 初始化答案为1,用于计算美丽值的乘积
        for c,num in sorted(cnt.items(),reverse = True):  # 从高到低遍历出现次数
            if num >= k:  # 如果当前出现次数的字符数量足以构成长度为k的子序列
                return ans * pow(c,k,mod) * comb(num,k) % mod  # 直接返回结果
            ans = ans * pow(c,num,mod) % mod  # 将当前出现次数的字符的美丽值乘入答案
            k -= num  # 减少k值,以便使用更多的字符
        return 0  # 如果无法构成长度为k的子序列,返回0

Explore

在Python中,使用`collections.Counter`可以直接计算每个字符的出现次数。首先,通过`Counter(s)`获取字符串`s`中每个字符的出现次数,然后再次使用`Counter`对这些出现次数进行计数。这种方法是基于哈希表实现的,可以准确快速地统计字符及其出现次数,以及出现次数的频率。因此,只要输入是一个有效的字符串,这种方法都可以正确地统计每个字符的出现次数以及每个出现次数的字符数量。

题解中采用逆序遍历是基于假设:越高的字符出现次数对美丽值的贡献越大,因此首先使用出现次数最多的字符组合尝试构建子序列,以期达到最大美丽值。这种方法在大部分情况下是有效的,因为使用次数高的字符构建的子序列美丽值较大。然而,理论上可能存在特定情况,例如当需要的子序列长度k较长且高频字符不足以组成多个子序列时,可能会需要组合不同出现次数的字符以达到最优解。但在大多数实际情况下,此策略已足够接近最优解。

在实际应用中,可以通过预计算阶乘值并使用模逆元来高效计算组合数。特别是在模数是质数的情况下,利用费马小定理,可以通过计算阶乘的逆元来快速求解组合数,从而避免直接计算大数的阶乘和可能的溢出。此外,使用模数来进行所有运算可以有效防止溢出,同时保持计算的正确性和效率。

Python的`pow`函数内置了模幂运算的功能,可以直接计算`(base^exp) % mod`的值。这种方式不仅计算效率高,而且可以有效避免在幂运算过程中产生过大的中间值导致的溢出问题。通过在每次计算后立即应用模数约束,确保了运算结果始终在安全的数值范围内。这是一种在处理大数运算时常用且高效的方法。