【JZOJ】3424. 粉刷匠

Description

Time Limits: 1000 ms Memory Limits: 262144 KB
赫克托是一个魁梧的粉刷匠，而且非常喜欢思考= =

现在，神庙里有N根排列成一直线的石柱，从1到N标号，长老要求用油漆将这些石柱重新粉刷一遍。赫克托有K桶颜色各不相同的油漆，第i桶油漆恰好可以粉刷Ci根石柱，并且，C1+C2+C3…CK=N（即粉刷N根石柱正好用完所有的油漆）。长老为了刁难赫克托，要求相邻的石柱颜色不能相同。

喜欢思考的赫克托不仅没有立刻开始粉刷，反而开始琢磨一些奇怪的问题，比如，一共有多少种粉刷的方案？

为了让赫克托尽快开始粉刷，请你尽快告诉他答案。

Input

第一行一个正整数T，表示测试数据组数

对于每一组测试数据数据：

第1行：一个正整数K

第2行：K个正整数，表示第i桶油漆可以粉刷的石柱个数，Ci。

Output

对于每组输入数据，输出一行一个整数，表示粉刷的方案数mod 1000000007。

Sample Input

3

3

1 2 3

5

2 2 2 2 2

10

1 1 2 2 3 3 4 4 5 5

Sample Output

10

39480

85937576

Data Constraint

30% N≤10, T≤5

50% N≤15, T≤5

80% K≤15,Ci≤5,T≤500

100% K≤15,Ci≤6,T≤2000

思路

明显这是一道计数DP。
考虑题目给出状态数（6^15），打表会遭?
考虑K,C值都很小，尤其C值（Ci<=6）。
不妨定义一个6维数组，每一位表示目前C值为当前维数值的油漆种类数，数组值为其方案数。
理论上，该DP是可以搞出来的，本蒟就不再此赘述。（没有勇气去打）

考虑一个正常的DP:
设dp[i][j]表示前i种颜色全涂上了（即现在总位置数Sum=${\sum }_{t=1}^i{c}_t$），
发现有j对位置是非合法的方案数。
则有dp[i][j+(a[i]-1)-(k-1)-t]=dp[i-1][j]*C(a[i]-1,k-1)*C(j,t)*C(Sum+1-j,k-t);
其中k表示将当前颜色的桶数分成k块，t表示分t个块去填之前的坑。

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define LL long long
const int MAXK=20;
const int MAXN=105;
const int MOD=1000000007;
LL dp[MAXK][MAXN];
int T,K,N,a[MAXN],Sum;
LL f[MAXN]={1},e[MAXN]={1};
LL quick_Pow(LL x,int y){
	if(y==0)return 1;
	if(y==1)return x;
	if(y%2)return (x*quick_Pow((x*x)%MOD,y/2))%MOD;
	return quick_Pow((x*x)%MOD,y/2);
}
LL C(int x,int y){
	return (((f[x]*e[y])%MOD)*e[x-y])%MOD;
}
void Add(LL &x,LL y){x=(x+y)%MOD;}
int main(){
	for(int i=1;i<=100;i++){
		f[i]=(f[i-1]*i)%MOD;
		e[i]=quick_Pow(f[i],MOD-2);
	}
	scanf("%d",&T);
	while(T--){//2000
		memset(dp,0,sizeof(dp));
		scanf("%d",&K);N=Sum=0;
		for(int i=1;i<=K;i++)
			scanf("%d",&a[i]),N+=a[i];
		sort(a+1,a+K+1);
		dp[1][a[1]-1]=1;Sum+=a[1];
		for(int i=2;i<=K;i++){
			for(int j=0;j<=Sum;j++)
				for(int k=1;k<=a[i];k++)
					for(int t=0;t<=k;t++){
						if(j+a[i]-k-t<0)continue;
						if(Sum+1-j<k-t)continue;
						if(j<t)continue;
						Add(dp[i][j+(a[i]-1)-(k-1)-t],(((dp[i-1][j]*C(a[i]-1,k-1))%MOD)*((C(j,t)*C(Sum+1-j,k-t))%MOD))%MOD);
					}
			Sum+=a[i];
		}
		printf("%lld\n",dp[K][0]);
	}
}
/*
k:分成k块   t:分t个块去填坑.
dp[i][j+(a[i]-1)-(k-1)-t]=dp[i-1][j]*C(a[i]-1,k-1)*C(j,t)*C(Sum+1-j,k-t);
                                       按序分配.
*/