【组合数学 放球问题 虚拟点 小于等于转小于】1621. 大小为 K 的不重叠线段的数目

本文涉及知识点

放球问题
组合数学汇总
本题难道分：2198

LeetCode1621. 大小为 K 的不重叠线段的数目

给你一维空间的 n 个点，其中第 i 个点（编号从 0 到 n-1）位于 x = i 处，请你找到 恰好 k 个不重叠 线段且每个线段至少覆盖两个点的方案数。线段的两个端点必须都是 整数坐标 。这 k 个线段不需要全部覆盖全部 n 个点，且它们的端点 可以 重合。
请你返回 k 个不重叠线段的方案数。由于答案可能很大，请将结果对 109 + 7 取余 后返回。
示例 1：

输入：n = 4, k = 2
输出：5
解释：
如图所示，两个线段分别用红色和蓝色标出。
上图展示了 5 种不同的方案 {(0,2),(2,3)}，{(0,1),(1,3)}，{(0,1),(2,3)}，{(1,2),(2,3)}，{(0,1),(1,2)} 。
示例 2：

输入：n = 3, k = 1
输出：3
解释：总共有 3 种不同的方案 {(0,1)}, {(0,2)}, {(1,2)} 。
示例 3：

输入：n = 30, k = 7
输出：796297179
解释：画 7 条线段的总方案数为 3796297200 种。将这个数对 109 + 7 取余得到 796297179 。
示例 4：

输入：n = 5, k = 3
输出：7
示例 5：

输入：n = 3, k = 2
输出：1

提示：

2 <= n <= 1000
1 <= k <= n-1

放球问题(错误解法）

二个盒子：
(0,2),(2,3) 两个盒子，第一个盒子2个球，第二个盒子1个球。
(0,1),(1,3)两个盒子，第一个盒子1个球，第二个盒子2个球。
三个盒子：
三个盒子，每个盒子一个球，然后仍掉一个盒子。
(0,1),(1,3) 扔掉第二个盒子。
(1,2),(2,3) 扔掉第一个盒子。
(0,1),(1,2)扔掉第三个盒子。
球完全相同，因为第一个盒子只能是：{0,1$\dots$}
盒子不同，二个盒子的两个情况，分别是{2,1}和{1,2}。
盒子不能为空。

从k到n-1枚举i，将n-1个球放到i个盒子中，然后乘以C${}_i^{i-k}$ ，表示扔掉i-k个盒子。
f(i) = C${}_{n-2}^{i-1}$ $\times$ C${}_i^{i-k}$
ret = ${\sum }_{i:k}^{n-1}$f(i)

i个盒子 和i+1 个盒子，前者扔掉一个盒子，后者扔掉2个盒子后，可能和前者重复。如：
{1,1,2} {1,1,1,1} 扔掉2和{1,1}后，为{1,1}。

组合数学

本题 $⟺$ 0 <= l1 < r1 <=l2 < r2 $\cdots$ lk < rk < n (l1,r1$\cdots$ lk,rk)的组合数。
令 lli = li+i rri = ri+i , (li,ri)和(lli,rri)一一对应，故数量相等。
1 <= ll1 < rr1 < ll2 < rr2 $\cdots$ llk < rrk < n+k $⟺$ 从[1,n+k-1)中寻找2k 个不同的数。
即：C${}_{n+k-1}^{2k}$

核心代码

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 numberOfSets(int n, int k) {
		
		CCombination com;
        C1097Int<> biRet = com.Get(2*k,n+k-1);
		return biRet.ToInt();
	}
};

测试用例

template<class T>
void Assert( vector<T> v1,  vector<T> v2)
{
	if (v1.size() != v2.size())
	{
		assert(false);
		return;
	}
	for (int i = 0; i < v1.size(); i++)
	{
		assert(v1[i] == v2[i]);
	}
}

template<class T>
void Assert(const T& t1, const T& t2)
{
	assert(t1 == t2);
}

int main()
{	
	int k;
	{
		Solution slu;
		auto res = slu.numberOfSets(30, 27);
		Assert(res, 1540);
	}
	{
		Solution slu;
		auto res = slu.numberOfSets(4,2);
		Assert(res, 5);
	}
	{
		Solution slu;
		auto res = slu.numberOfSets(3,1);
		Assert(res, 3);
	}
	
	{
		Solution slu;
		auto res = slu.numberOfSets(5, 3);
		Assert(res, 7);
	}
	{
		Solution slu;
		auto res = slu.numberOfSets(3, 2);
		Assert(res, 1);
	}
	{
		Solution slu;
		auto res = slu.numberOfSets(30, 7);
		Assert(res, 796297179);
	}
}

组合数学+ 虚拟点

如果起点和终点不重合，则 C${}_n^{2k}$ 。
假定有i1个重合点，那一定有2n-i1个非重合点，i1$\in$ [0,k-1] 第一条线段 的起点不会是重合点。
从n个真实点和k-1个虚拟点，共n+K-1个点中选取2k个点。一定对应一个合法方案,且不会重复。

至少存在一个方案

将选择真实点排序后放到队列中，is[i] 表示第i个虚拟节点是否选取。
队列中的前两个节点是第一条线段，队列出队两个元素。
for( i = 0 to k-1)
$$\{\begin{array}{llc}新线段=(前一个线段的终点,队首),出队& & is[i]\\ 新线段=队伍的前两个元素,出队两个元素& & else\end{array}$$
总共2k个点，每次处理2次，k次刚好处理完。
虚拟节点只有有，才处理。所以不会不足。最多k-1个，处理k-1次。所以不会剩余。
节点一定处理完，虚拟处没有不足或剩余，故真实节点也没不足或处理完。

不会有其它对应方案

按语义操作是唯一的，故不存在其它方案。

方案数不重复

一，虚拟节点数不同，则一定不同。
二，虚拟节点数量相同，但至少某个虚拟节点不同。虚拟节点排序后，令两个方案最小不同节点分别为i1,i2。i3 = min(i1,i2)。
$$\{\begin{array}{llc}两方案不同& & (i3-1)的终点不同。\\ 第i3条线段的起点一定不同& & other\end{array}$$
三，虚拟节点完全相同，真实节点不同。
真实节点排序后，令最小不同的节点分别为i1,i2。不失一般性。令这两个节点都是第i3条线段的起点。则第i3条线段起点不同。

​

扩展阅读

视频课程

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

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

相关下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
《喜缺全书算法册》以原理、正确性证明、总结为主。
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

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