【bzoj2616】SPOJ PERIODNI 树形DP

给定一个N列的表格，每列的高度各不相同，但底部对齐，然后向表格中填入K个相同的数，填写时要求不能有两个数在同一列，或同一行，下图中b是错误的填写，a是正确的填写，因为两个a虽然在同一行，但它们中间的表格断开。 

输出所有填写方案数对1 000 000 007的余数。
输入：
第一行两个整数 N 和 K  (1 ≤ N ≤ 500, 1 ≤ K ≤ 500),表示表格的列数，和要填写的数的个数。
接下来一行N个数，表示每列的高度。高度不超过 1 000 000.
输出：
一个整数，方案总数对1000 000 007的余数。

注意：

对于 40% 的数据, 所有数值小于15.
对于70% 的数据，所有数值小于100.
样例：
输入：
3 3
2 1 3
输出：
2
输入：
4 1
1 2 3 4
输出：
10
输入：
5 2
2 3 1 2 4
输出：
43
输出：
3 2
999999 999999 999999
输出：

990979013

f[i,j]表示以i为根的树上放j个字符的方案总数。
g[i,j]表示以i为根的树左右儿子共填j个字符的方案总数

用 h[a,b,k] 表示底边长为a，高为b的矩形中放k个字符的方案总数。根据组合数学 有：

因为要取模 ， 用逆元exgcd； 若 C 为B 的逆元，（ A / B）% P = （A * C ）% P；

#include<cstdio>
#include<iostream>
#include<algorithm>
#define LL long long
using namespace std;
const int N = 1001, M = 1000001;
const LL MOD = 1000000007;
int n, K, root, G, H[N], h[N], len[N], son[N][2];
LL A[M], g[N][N], f[N][N];
void exgcd(LL a, LL b, LL &g, LL &x, LL &y) {
	if(!b) { g = a; x = 1LL; y = 0LL; return; }
	exgcd(b, a%b, g, y, x); y -= a/b*x;
}
void built(int &k, int l, int r) {
	int s = r; 
	if(l > r) return;
	if(!k) k = ++G;
	for(int i = l; i < r; i++) 
		if(H[i] < H[s]) s = i;
	len[k] = r-l+1; h[k] = H[s];
	for(int i = l; i <= r; i++) 
		H[i] -= h[k];
	built(son[k][0], l, s-1);
	built(son[k][1], s+1, r);
}
LL calc(int a, int b, int k) {
	if(!k) return 1;
	if(a < k || b < k) return 0;
	LL fz = (A[a] * A[b]) % MOD;
	LL fm = (A[a-k] * A[b-k]) % MOD;
	LL y, x, g;
	fm = (fm * A[k]) % MOD;
	exgcd(fm, MOD, g, x, y);
	x = (x < 0) ? x += MOD : x;
	return (fz * x) % MOD;
}
void Dfs(int k) {
	g[k][0] = f[k][0] = 1;
	if(!k) return;
	Dfs(son[k][0]); Dfs(son[k][1]);
	for(int i = 1; i <= K; i++)
		for(int j = 0; j <= i; j++) 
			g[k][i] = (g[k][i]+f[son[k][0]][j]*f[son[k][1]][i-j]) % MOD;
	for(int i = 1; i <= K; i++)
		for(int j = 0; j <= i; j++)
			f[k][i] = (f[k][i]+g[k][j]*calc(len[k]-j, h[k], i-j)) % MOD;
}
int main() {
	scanf("%d%d\n", &n, &K); 
	A[0] = 1LL;
	for(int i = 1; i <= n; i++) 
		scanf("%d", &H[i]);
	for(int i = 1; i <= M; i++) 
		A[i] = ((LL)i * A[i-1]) % MOD;
	built(root, 1, n); 
	Dfs(root);
	printf("%lld\n", f[root][K]);
  	return 0;
}