TopCoder SRM 489 Div1 Lev3：AppleTree

挺优秀的一道题，想出做法时有些惊艳。

题意：

数轴上有\(D\)个连续整数刻度，有\(N\)棵树要种在这些刻度上，其中第\(i\)棵与两旁（如果有的话）相邻的树至少要相距\(R_i\)，问方法数。

\(1 \leq N , R_i \leq 40\)

思路：

首先，如果确定了种树的顺序，就确定了相邻树的最小间距。把\(D\)减掉最小间距之和，所得的就是“冗余刻度”的数量。

把这个数量分配给\(N+1\)段间隙，用插板法可以求出方法数。

所以问题在于，对于每一个\(L\)，求出1到\(N\)的排列\(P\)的数量，满足：

\[\sum_{i=1}^{N-1} \mathrm{max}(R_{P_i}, R_{P_{i+1}})=L
\]

注意到，对于使\(R_i\)最大的\(i\)，它的两侧种的是什么树，不影响这两段间隙的最小长度。

根据套路，这个时候我们应该在\(i\)的位置把排列割开并分别处理。

对于一个1到\(N\)的子集的长度为\(l\)的排列\(P\)，定义其代价为：\(\sum_{i=1}^{l-1} \mathrm{max}(R_{P_i}, R_{P_{i+1}})\)。

我们先把\(R\)数组从小到大排序，接着DP：\(dp[i][j][k]\)表示，1到\(i\)这\(i\)个数，组成了\(j\)个不相交排列，排列的代价总和为\(k\)的方法数。

转移时考虑第\(i\)个数在一个排列的两端还是中间，删除之，加上第\(i\)个数两侧的空隙长度并转移即可。把树排序的意义在于，排序后第\(i\)棵树一定是\([1,i]\)中\(R\)值最大的那个。

注意到\(i,j \leq 40\)，\(k \leq 1600\)，故复杂度没有问题。

等等，正确性有问题……

因为长度为1的排列只有一个端点，而在先前的状态中很难区分长度为1和大于1的排列，故无法求出转移时乘的系数。

所以不妨直接考虑从长度为1的那些排列入手，发现……可以用它们合并成更长的排列？

于是想到可以DP状态不变，转移做如下修改：

首先，初始状态\(dp[0][0][0]=1\)。

其次，允许通过以下方式转移：

1、把\(i+1\)单独组成一个长为1的排列

2、任选两个排列，把\(i\)放在中间将其连接

3、任选一个排列，把\(i\)吸附在其端点旁边

这样把\(i+1\)添加进当前的排列集合之后，就可以转移到\(i'=i+1\)的情况。

对于每一个\(L\)，求出1到\(N\)的排列\(P\)的数量，满足\(\sum_{i=1}^{N-1} \mathrm{max}(R_{P_i}, R_{P_{i+1}})=L\)

而对于每一个\(L\)，要求的值就是\(dp[N][1][L]\)。Bingo！

代码：

// BEGIN CUT HERE

// END CUT HERE
#line 5 "AppleTrees.cpp"
#include <bits/stdc++.h>
using namespace std;
#define iinf 2000000000
#define linf 1000000000000000000LL
#define ulinf 10000000000000000000ull
#define MOD 1000000007LL
#define lson(v) ((v)<<1)
#define rson(v) (((v)<<1)^1)
#define mpr make_pair
typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned long UL;
typedef unsigned short US;
typedef pair < int , int > pii;
clock_t __stt;
inline void TStart(){__stt=clock();}
inline void TReport(){printf("\nTaken Time : %.3lf sec\n",(double)(clock()-__stt)/CLOCKS_PER_SEC);}
template < typename T > T MIN(T a,T b){return a<b?a:b;}
template < typename T > T MAX(T a,T b){return a>b?a:b;}
template < typename T > T ABS(T a){return a>0?a:(-a);}
template < typename T > void UMIN(T &a,T b){if(b<a) a=b;}
template < typename T > void UMAX(T &a,T b){if(b>a) a=b;}
int n,dp[42][42][1655],fac[100005];
int inv(int val){
	int ret=1,tms=MOD-2;
	while(tms){
		if(tms&1) ret=((LL)ret*(LL)val)%MOD;
		val=((LL)val*(LL)val)%MOD;
		tms>>=1;
	}
	return ret;
}
int C(int n,int m){
	if(n<m) return 0;
	if(!n) return 1;
	int u=fac[n],d=((LL)fac[m]*(LL)fac[n-m])%MOD;
	return ((LL)u*(LL)inv(d))%MOD;
}
class AppleTrees {
	public:
	int theCount(int D, vector <int> r){
		sort(r.begin(),r.end());
		n=(int)r.size();
		int i,j,k,res=0;
		fac[0]=1;
		for(i=1;i<=D;++i){
			fac[i]=((LL)fac[i-1]*(LL)i)%MOD;
		}
		dp[0][0][0]=1;
		for(i=0;i<n;++i){
			for(j=0;j<=n;++j){
				for(k=0;k<=1620 && k<=D;++k){
					if(!dp[i][j][k]) continue;
					dp[i+1][j+1][k]+=dp[i][j][k];
					dp[i+1][j+1][k]%=MOD;
					dp[i+1][j][k+r[i]]+=((LL)dp[i][j][k]*2LL*(LL)j)%MOD;
					dp[i+1][j][k+r[i]]%=MOD;
					if(j>1){
						dp[i+1][j-1][k+2*r[i]]+=((LL)dp[i][j][k]*(LL)j*(LL)(j-1))%MOD;
						dp[i+1][j-1][k+2*r[i]]%=MOD;
					}
				}
			}
		}
		for(i=1;i<=1620 && i<=D;++i){
			res+=((LL)dp[n][1][i-1]*(LL)C(D-i+n,n))%MOD;
			res%=MOD;
		}
		return res;
	}
};