[组合数学]LeetCode:2954:统计感冒序列的数目

news2024/11/24 17:40:47

作者推荐

[二分查找]LeetCode2040:两个有序数组的第 K 小乘积

题目

给你一个整数 n 和一个下标从 0 开始的整数数组 sick ，数组按升序排序。
有 n 位小朋友站成一排，按顺序编号为 0 到 n - 1 。数组 sick 包含一开始得了感冒的小朋友的位置。如果位置为 i 的小朋友得了感冒，他会传染给下标为 i - 1 或者 i + 1 的小朋友，前提是被传染的小朋友存在且还没有得感冒。每一秒中，至多一位还没感冒的小朋友会被传染。
经过有限的秒数后，队列中所有小朋友都会感冒。感冒序列指的是所有一开始没有感冒的小朋友最后得感冒的顺序序列。请你返回所有感冒序列的数目。
由于答案可能很大，请你将答案对 109 + 7 取余后返回。
注意，感冒序列不包含一开始就得了感冒的小朋友的下标。
示例 1：
输入：n = 5, sick = [0,4]
输出：4
解释：一开始，下标为 1 ，2 和 3 的小朋友没有感冒。总共有 4 个可能的感冒序列：

一开始，下标为 1 和 3 的小朋友可以被传染，因为他们分别挨着有感冒的小朋友 0 和 4 ，令下标为 1 的小朋友先被传染。
然后，下标为 2 的小朋友挨着感冒的小朋友 1 ，下标为 3 的小朋友挨着感冒的小朋友 4 ，两位小朋友都可以被传染，令下标为 2 的小朋友被传染。
最后，下标为 3 的小朋友被传染，因为他挨着感冒的小朋友 2 和 4 ，感冒序列为 [1,2,3] 。
一开始，下标为 1 和 3 的小朋友可以被传染，因为他们分别挨着感冒的小朋友 0 和 4 ，令下标为 1 的小朋友先被传染。
然后，下标为 2 的小朋友挨着感冒的小朋友 1 ，下标为 3 的小朋友挨着感冒的小朋友 4 ，两位小朋友都可以被传染，令下标为 3 的小朋友被传染。
最后，下标为 2 的小朋友被传染，因为他挨着感冒的小朋友 1 和 3 ，感冒序列为 [1,3,2] 。
感冒序列 [3,1,2] ，被传染的顺序：[0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] 。
感冒序列 [3,2,1] ，被传染的顺序：[0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] => [0,1,2,3,4] 。
示例 2：
输入：n = 4, sick = [1]
输出：3
解释：一开始，下标为 0 ，2 和 3 的小朋友没有感冒。总共有 3 个可能的感冒序列：
感冒序列 [0,2,3] ，被传染的顺序：[0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3] 。
感冒序列 [2,0,3] ，被传染的顺序：[0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3] 。
感冒序列 [2,3,0] ，被传染的顺序：[0,1,2,3] => [0,1,2,3] => [0,1,2,3] => [0,1,2,3] 。
参数范围：
2 <= n <= 10⁵
1 <= sick.length <= n - 1
0 <= sick[i] <= n - 1
sick 按升序排列。

分析

分段处理

因为病毒遇到已经感冒的小朋友会停止，所以未被感染的小孩，只会有被两个小孩感染直接或间接感染：
一，他左边，从右到左第一个初始感染的。
二，他右边，从左到右第一个初始感染的。
可以将其分成若干段。

各段处理

假定初始未感染的小孩数为m，如果无任何限制，则共有m! 种可能。m!是m的阶乘。
假定某段有len个小孩：
则此段被计算了len! 次。
实际可能数，如下表：


左边的那段	1
中间的段	2^len-1
右边的那段	1

除掉各段被计算的次数，乘以实际的可能数。

长度为0的段的处理

必须忽略，否则可能出错。无论是那一段长度为0和长度1的结果一样。所以可能将长度为0转化成成长度为1。

代码

复用代码

template
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;
}
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;;
};

核心代码

class Solution {
public:
	int numberOfSequence(int n, vector<int>& sick) {
		const int m = n - sick.size();
		vector<C1097Int<>> vFac(1,1);//记录[0,m]的阶乘
		for (int i = 1; i <= m; i++)
		{
			vFac.emplace_back(vFac.back() * i);
		}
		C1097Int<> iiRet = vFac[m];//如果没有任何限制 所有系列的可能数
		const int leftLen = max(1,sick.front());
		iiRet *= vFac[leftLen].PowNegative1();//扣除左端 被计算的可能数
		const int rightLen = max(1, (n - 1 - sick.back()));
		iiRet *= vFac[rightLen].PowNegative1();
		for (int i = 1; i < sick.size(); i++)
		{
			const int len = max(1,sick[i] - sick[i - 1]-1);
			iiRet *= vFac[len].PowNegative1();//扣除(sick[i-1],sick[i])之间的孩子被计算的可能数
			iiRet *= C1097Int<>(2).pow(len - 1);//乘以这些孩子的实际数量
		}
		return iiRet.ToInt();
	}
};