3424. 【NOIP2013模拟】粉刷匠 (Standard IO)

 

3424. 【NOIP2013模拟】粉刷匠 (Standard IO)

Time Limits: 1000 ms  Memory Limits: 262144 KB  Detailed Limits  

Description

赫克托是一个魁梧的粉刷匠，而且非常喜欢思考= =

现在，神庙里有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

Source / Author: paint

 

题解：

 

所以我们改进，每一步处理一种颜色。

 

我们新建一个序列初值为空。

对于第i种颜色要刷的ci个石柱 ， 我们抽象成ci个颜色为i的小球。看看放进那个序列中的dp贡献。

一次放完这种颜色。

 

设F[i][j]表示这个序列有i种颜色，有j对相邻的小球颜色相同。

 

如图：i=3 ：黄橙红

j=3 一共有两块红色的联通块 ， 第一块j=2 ， 第二块j=1， 2+1=3。 可以发现j就是相邻同色小球间的空隙个数。

然后：

记涂到第i种颜色之后一共有S个小球。

对于i+1这种颜色，有A个小球。

设把这A个小球分成k块，插进序列里面。

插进的位置中，有L个位置刚好插进在j对颜色相同的小球中间(L<=j 且 L<=k)。

 

新状态的j：原有的j，新增的A-k，减少的L。

状态转移：

1 把小球分成k块的方案数：C(A-1, k-1)

2 把块插进l个位置的方案数：C(j, L)

3 剩余块的处理方式：C(S+1-j, k-L)

转移方程如下：

F[i+1][j+A-k-l] += F[i][j] * C(j, L) * C(A-1, k-1) * C(S+1-j, k-L)

 

 

#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define mcy(a,b) memcpy(a,b,sizeof(a))
#define inf 2000000000
#define ll long long
#define N 25
#define M 110
#define mod 1000000007
#define open(x) freopen(x".in","r",stdin);freopen(x".out","w",stdout)
using namespace std;

ll T,i,j,k,l,t,ans,n;
ll f[N][M],c[N],fact[M],factinv[M];

ll C(ll m,ll n)
{return fact[m] * factinv[n] % mod * factinv[m-n] % mod;}

void dp()
{
	ll A=0 , S=0;
	ll i=0,j=0,k=0,l=0;
	f[0][0] = 1;
	for(i=0;i<n;i++)
	{
		S += c[i];
		A = c[i+1]; 
		for(j=0;j<=S;j++)
			for(k=1;k<=A;k++) 
			{
				for(l=0;l<=j;l++) if(l<=k)
					(f[i+1][j+A-k-l] += f[i][j]* C(A-1 , k-1)%mod * C(j,l)%mod * C(S+1-j , k-l)%mod)%= mod;
			}
	}
}
ll sqr(ll x) {return x*x%mod;}
ll power(ll x,ll p) 
{
	if(p==0) return 1;
	if(p&1) return x*sqr(power(x,p/2)) %mod; 
	return sqr(power(x,p/2));
}

void init()
{
	fact[0]  = 1;
	for(ll i=1;i<=100;i++) fact[i] = fact[i-1] * i % mod;
	factinv[100] = power(fact[100] , mod-2);
	for(ll i=99;i>=0;i--) factinv[i] = factinv[i+1] * (i+1) % mod;
	return ;
}

int main()
{
	init();
	scanf("%lld",&T);
	
	while(T--)
	{
		scanf("%lld",&n);
		for(i=1;i<=n;i++) scanf("%lld",&c[i]);
		mem(f,0);
		dp();
		printf("%lld\n",f[n][0]);
	}
	return 0;
}

时间复杂度O(K*N*C*C*T)。