推荐|【组合数学】2842. 统计一个字符串的 k 子序列美丽值最大的数目

本文涉及知识点

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

给你一个字符串 s 和一个整数 k 。
k 子序列指的是 s 的一个长度为 k 的子序列，且所有字符都是唯一的，也就是说每个字符在子序列里只出现过一次。
定义 f© 为字符 c 在 s 中出现的次数。
k 子序列的美丽值定义为这个子序列中每一个字符 c 的 f© 之和。
比方说，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 在字符串 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 * 10⁵
1 <= k <= s.length
s 只包含小写英文字母。

组合数学

一，计算a到z的f值。
二，由大到小排序。
三，大于f[k-1]的字母一定会被选取。等于f[k-1]可能被选取，也可能不被选取。小于f[k-1]的一定不会被选取。如果被选取，选择任意一下标。
结果为：ret1 $\times$ ret2
$ret1=\Pi_{f[i]>f[k-1]}f[i]$
令有m个数大于f[k-1],有e个数和f[k-1]相等，包括f[k-1]。
$\choose k-m}f[k-1]^{k-m}$

代码

核心代码

template<int MOD = 1000000007>
class C1097Int
{
public:
	C1097Int(long long llData = 0) :m_iData(llData% MOD)
	{

	}
	C1097Int  operator+(const C1097Int& o)const
	{
		return C1097Int(((long long)m_iData + o.m_iData) % MOD);
	}
	C1097Int& operator+=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData + o.m_iData) % MOD;
		return *this;
	}
	C1097Int& operator-=(const C1097Int& o)
	{
		m_iData = (m_iData + MOD - o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator-(const C1097Int& o)
	{
		return C1097Int((m_iData + MOD - o.m_iData) % MOD);
	}
	C1097Int  operator*(const C1097Int& o)const
	{
		return((long long)m_iData * o.m_iData) % MOD;
	}
	C1097Int& operator*=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData * o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator/(const C1097Int& o)const
	{
		return *this * o.PowNegative1();
	}
	C1097Int& operator/=(const C1097Int& o)
	{
		*this /= o.PowNegative1();
		return *this;
	}
	bool operator==(const C1097Int& o)const
	{
		return m_iData == o.m_iData;
	}
	bool operator<(const C1097Int& o)const
	{
		return m_iData < o.m_iData;
	}
	C1097Int pow(long long n)const
	{
		C1097Int iRet = 1, iCur = *this;
		while (n)
		{
			if (n & 1)
			{
				iRet *= iCur;
			}
			iCur *= iCur;
			n >>= 1;
		}
		return iRet;
	}
	C1097Int PowNegative1()const
	{
		return pow(MOD - 2);
	}
	int ToInt()const
	{
		return m_iData;
	}
private:
	int m_iData = 0;;
};

template<class Result = C1097Int<> >
class CCombination
{
public:
	CCombination()
	{
		m_v.assign(1, vector<Result>(1,1));
	}
	Result Get(int sel, int total)
	{
		assert(sel <= total);
		while (m_v.size() <= total)
		{
			int iSize = m_v.size();
			m_v.emplace_back(iSize + 1, 1);
			for (int i = 1; i < iSize; i++)
			{
				m_v[iSize][i] = m_v[iSize - 1][i] + m_v[iSize - 1][i - 1];
			}
		}
		return m_v[total][sel];
	}
protected:
	vector<vector<Result>> m_v;
};

class Solution {
public:
	int countKSubsequencesWithMaxBeauty(string s, int k) {
		if (k > 26) { return 0; }
		vector<int> f(26);
		for (const auto& ch : s) {
			f[ch - 'a']++;
		}
		auto vSort = f;
		sort(vSort.begin(), vSort.end(),std::greater<>());
		C1097Int<> biRet = 1;
		int i = 0;
		for (; (i < 26) && (vSort[i] > vSort[k - 1]); i++) {
			biRet *= vSort[i];
		}
		const int hasSel = i;
		int iEqualCnt = 0;
		for (; (i < 26) && (vSort[i] == vSort[k - 1]); i++) {
			iEqualCnt ++;
		}
		CCombination com;
		biRet *= com.Get(k - hasSel, iEqualCnt);
		biRet *= C1097Int<>(vSort[k - 1]).pow(k - hasSel);
		return biRet.ToInt();
	}
};

扩展阅读

视频课程

有效学习：明确的目标及时的反馈拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者操作系统：win10 开发环境： VS2022 C++17
如无特殊说明，本算法用**C++**实现。

文章知识点与官方知识档案匹配，可进一步学习相关知识

算法技能树首页概览61211 人正在系统学习中

群中有博文配套源码

QQ群名片

【组合数学】2842. 统计一个字符串的 k 子序列美丽值最大的数目