B - Fabricating Sculptures

题目链接：

Fabricating Sculptures

---

题意:

 给定一个底座的列数,要求底座必须填满，且上层方块的组成不能出现凹槽的形状，问底层为n，共有m个方块的摆放方式有几种

---

思路：

 我们可以发现，每一层向上，所有的方块都必须是连续的且保持从上到下满足递减的顺序，那么我们可以得到先定义dp状态：

dp[n,m] 以n为底层时剩余m个方块的摆放方式的数量

那么可以得到递推公式如下

dp[i,j] = i * dp[1,j - 1] + (i - 1) * dp[2,j - 2] ... (i - k + 1) * dp[k,j - k];
k = min(i,j)//因为最多一排放i个但是可能j不够i个，所以取i, j 的最小值

但是这样直接三层循环暴力跑一定会tle，所以要进行优化

以dp[4,3]为例:
dp[4,3] = 4 * dp[1,2] + 3 * dp[2,1] + 2 * dp[3,0];
dp[3,3] = 3 * dp[1,2] + 2 * dp[2,1] + dp[3,0];
dp[2,3] = 2 * dp[1,2] + dp[2,1];
dp[1,3] = dp[1,2];

我们两两相减
可以得到 dp[4,3] - dp[3,3] = dp[1,2] + dp[2,1] + dp[3,0];
		dp[3,3] - dp[2,3] = dp[1,2] + dp[2,1] + dp[3,0];
		dp[2,3] - dp[1,3] = dp[1,2] + dp[2,1];
我们如果画成矩阵表示可以发现，每一次加的都是[1,2]向左下角一直走的dp
值，如果是就j >= i的话就是以dp[i,j - i]结束,我们发现除dp[i,j - i]
结束外，这个的差值就是dp[i - 1,j] - dp[i - 2,j]的差值，所以我们可以
优化为
dp[i,j]=dp[i - 1,j]+dp[i - 1,j]+dp[i - 2,j]+if(j >= i)+dp[i,j - i]
 
用上面的例子dp[4,3] = dp[3,3] - dp[2,3] + dp[3,3]
如果是 j >= i的话，是这样的，比如
dp[3,3] = dp[2,3] - dp[1,3] + dp[2,3] + dp[3,0];
可以拿每两项的公式减一下，就可以得到上面的规律，每一次的递增值都是
前两项的差值 那么加上 dp[i - 1,j]，以及如果j >= i那么就要加上dp[i,j - i]
就可以得到dp[i,j]
所以优化后的公式如下:
dp[i,j] = dp[i - 1,j] + dp[i - 1,j] - dp[i - 2,j]
if j >= i dp[i,j] += dp[i,j - i];
此外，注意下取模问题

代码如下:

#include <iostream>
#include <cstdio>
#include <cstdlib>

using namespace std;

typedef long long ll;

const int maxn = 5e3 + 10;
const int mod = 1e9 + 7;

ll dp[maxn][maxn];
//dp[n,m] 当前层为n时,上方剩余m个块时能组成多少种情况

void Solve(int n, int m)
{
	for(int i = 0; i <= maxn; i++) dp[i][0] = dp[1][i] = 1,dp[2][i] = i + 1; 
	for(int i = 3; i <= n; i++){
		for(int j = 0; j <= m; j++){
			dp[i][j] = (2 * dp[i - 1][j] % mod - dp[i - 2][j] % mod + mod) % mod;
			if(j >= i)	dp[i][j] = (dp[i][j] % mod + dp[i][j - i] % mod) % mod; 
		}
	}
	cout<<dp[n][m] % mod<<endl;
}

int main()
{
	int n,m;
	cin>>n>>m;
	m -= n;
	Solve(n,m);
	//system("pause");
	return 0;
}