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

作者推荐

[二分查找]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! 次。

实际可能数，如下表：

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

长度为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();
  }
};

。也就是我们常说的专业的人做专业的事。 |

|如果程序是一条龙，那算法就是他的是睛|

测试环境

操作系统：win7 开发环境： VS2019 C++17

或者 操作系统：win10 开发环境：

VS2022 C++17