8-机器分配(hud4045-组合+第二类斯特林数)

http://acm.hdu.edu.cn/showproblem.php?pid=4045
　　　　　　　　　　　　　　　　　　　　　Machine scheduling
Time Limit: 5000/2000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1933 Accepted Submission(s): 711

Problem Description
A Baidu’s engineer needs to analyze and process large amount of data on machines every day. The machines are labeled from 1 to n. On each day, the engineer chooses r machines to process data. He allocates the r machines to no more than m groups ,and if the difference of 2 machines' labels are less than k,they can not work in the same day. Otherwise the two machines will not work properly. That is to say, the machines labeled with 1 and k+1 can work in the same day while those labeled with 1 and k should not work in the same day. Due to some unknown reasons, the engineer should not choose the allocation scheme the same as that on some previous day. otherwise all the machines need to be initialized again. As you know, the initialization will take a long time and a lot of efforts. Can you tell the engineer the maximum days that he can use these machines continuously without re-initialization.

Input
Input end with EOF.
Input will be four integers n,r,k,m.We assume that they are all between 1 and 1000.

Output
Output the maxmium days modulo 1000000007.

Sample Input
5 2 3 2

Sample Output
6

Hint

Sample input means you can choose 1 and 4,1 and 5,2 and 5 in the same day.
And you can make the machines in the same group or in the different group.
So you got 6 schemes.
1 and 4 in same group,1 and 4 in different groups.
1 and 5 in same group,1 and 5 in different groups.
2 and 5 in same group,2 and 5 in different groups.
We assume 1 in a group and 4 in b group is the same as 1 in b group and 4 in a group.

Source
The 36th ACM/ICPC Asia Regional Beijing Site —— Online Contest

Recommend
lcy | We have carefully selected several similar problems for you: 4043 4049 4046 4041 4047

题意：有N个机器，每天选出R个机器，而且每两个机器的编号差要大于等于K，每天将这R个机器最多分为M组工作，问最多有多少种方案。

思路：问题由两部分构成：第一，从N个机器中选出R个满足条件的机器的方案数；第二，将R个机器最多分为M组有的方案数。二者乘积即为答案。

第一部分：

先满足每两个机器之间至少有K-1个间隔，也就是还剩下rem=n-((r-1)*k+1)个机器可以随意安排，把这些多余的插入到R个机器之间(加上两端共R+1个位置)。问题也就变为rem个相同的球分到R+1个不同的组可以为空这种模型，不难推出是C(rem+R，R)，网上有说直接用插板法公式。可参考：插板法

因为选出的r个机器是相对固定的，考虑其他情况是就要考虑剩余的rem个的处理，保持间隔大于等于k就行，也就是说原来选的数列中间可以在插入剩余的数，间隔有r + 1 个，故相当于将剩下的分为r+1分放入，即插入r块板子，但可以插入空，即相当于分成的份数是小于等于r+1的，所以是板子是1， 2，... r；则种类有：C(ren + 1, 1) + C(ren + 1, 2) +...+C(ren + 1, r) = C(ren + r, r) ==》利用的是：C(n - 1, m - 1) + C(n - 1, m) = C(n , m)

第二部分：R个元素分为i个非空集合是第二类斯特林数，对i为1至m求和即可。

第二类Stirling数 (  https://baike.baidu.com/item/%E6%96%AF%E7%89%B9%E6%9E%97%E6%95%B0/4938529?fr=aladdin   )

定义

第二类Stirling数实际上是集合的一个拆分，表示将n个不同的元素拆分成m个集合的方案数，记为

  

或者

  

。和第一类Stirling数不同的是，集合内是不考虑次序的，而圆排列是有序的。常常用于解决组合数学中几类放球模型。描述为：将n个不同的球放入m个无差别的盒子中，要求盒子非空，有几种方案？

第二类Stirling数要求盒子是无区别的，所以可以得到其方案数公式：

递推式

第二类Stirling数的推导和第一类Stirling数类似，可以从定义出发考虑第n+1个元素的情况，假设要把n+1个元素分成m个集合则分析如下：

（1）如果n个元素构成了m-1个集合，那么第n+1个元素单独构成一个集合。方案数  。

（2）如果n个元素已经构成了m个集合，将第n+1个元素插入到任意一个集合。方案数 m*S(n,m) 。

综合两种情况得：

　　

性质

①

 

②

 

③

 

 

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long ll;
int c[2005][2005];
ll s[1004][1005];  		//这里用int就wa!!!
ll mod = 1e9+7;

ll cjj(int n, int r){   //递归求阶乘
	if(c[n][r] != 0){
		return c[n][r];
	}
	if(r == 0)
		return c[n][r] = 1;
	if(n == 0 || n < r)
		return c[n][r] = 0;
	if(r == n)
		return c[n][r] = 1;
	return c[n][r] = (cjj(n - 1, r) + cjj(n - 1, r - 1)) % mod;
}
ll sitelin(int n, int m){ //第二类斯特林数
	if(s[n][m] != 0){
		return s[n][m];
	}
	if(m == 0)
		return s[n][m] = 1;
	if(m == 1)
		return s[n][m] = 1;
	if(n == m)
		return s[n][m] = 1;
	if(n < m)
		return s[n][m] = 0;  //注意
	return s[n][m] = (sitelin(n - 1, m - 1) + sitelin(n - 1, m) * m) % mod;
}
void init(){
	for(int i = 0; i <= 1000; i++){
		for(int j = 0; j <= 1000; j++){
			cjj(i, j);
		}
	}
	for(int i = 0; i <= 1000; i++){
		for(int j = 0; j <= 1000; j++){
			sitelin(i, j);
		}
	}
}
//void init ()
//{
//	int i, j;
//	for (i=1;i<=2000;i++)  //递推求
//	{
//		c[i][0] = c[i][i]=1;
//		for (j=1;j<i;j++)
//			c[i][j] = (c[i-1][j-1] + c[i-1][j]) % mod;
//	}
//	for (i = 1; i <= 1000; i++){
//	    s[i][0] = 0;
//	    s[i][i] = 1;
//	    for(j = 1; j < i; j++) // <= WA
//            s[i][j] = (s[i-1][j-1] + j * s[i-1][j]) % mod;
//    }
//}
int main(){
	int n, r, k, m;
	init();

	while(scanf("%d%d%d%d", &n, &r, &k, &m) != EOF){
		ll sum = 0;
		int ren = n - ((r - 1) * k + 1);
		if(ren < 0){  	//必须单独考虑不满足的情况
			printf("0\n");
			continue;
		}
		for(int i = 1; i <= m; i++){
			sum = (sum + s[r][i]) % mod;
		}
		printf("%lld\n", sum * c[ren + r][r] % mod);
	}

	return 0;
}