【2024.1.31练习】积木画（20分）

题目描述

---

题目思路

第一次建立状态的思路是二维数组，代表所用I型积木个数，代表所用L型积木个数。的值代表此时填充画布的总方案数。由于题目中特意强调了每块积木单位面积，计算得到最大积木数为块，但是这样数组过大，会导致运行超时。

直接硬着头皮建立一维数组，代表长度为时积木的拼接方案数。假设从左往右放置积木，关注最右边的积木，容易发现最右侧的积木最多只会存在4种类型：I型积木竖着放；两个I型积木横着放（简称O型）；L型积木镜像对称放（简称┛）；L型积木镜像对称再上下对称放（简称┓）。

长度N	I型	O型	┛型	┓型	总方案数
1	1	0	0	0	1
2	1	1	0	0	2
3	2	1	1	1	5
4	5	2	2	2(1+1)	11
5	11	5	4	4(2+1+1)	24
6	24	11	9	9(5+2+1+1)	53

本质上只是一个找规律的游戏。

由此可以设计初始状态，代表末尾为I型积木的方案数；代表末尾为O型积木的方案数；代表末尾为┛型积木的方案数；代表末尾为┓型积木的方案数；代表画布长度为的总方案数；

建立状态转移方程：

---

我的代码

由于1e9+7很接近int的最大值。为了避免int溢出，改用longlong类型储存数据。

#include <iostream>
#include <algorithm>
using namespace std;
const int max_n = 1e7+2;
typedef long long ll;
ll dp[max_n][5];
int main() {
	int n;
	cin >> n;
	//建立初始状态
	dp[1][0] = 1;
	dp[1][1] = 0;
	dp[1][2] = 0;
	dp[1][3] = 0;
	dp[1][4] = 1;
	dp[2][0] = 1;
	dp[2][1] = 1;
	dp[2][2] = 0;
	dp[2][3] = 0;
	dp[2][4] = 2;
	dp[3][0] = 2;
	dp[3][1] = 1;
	dp[3][2] = 1;
	dp[3][3] = 1;
	dp[3][4] = 5;
	ll sum = 1;
	//动态规划
	for (int i = 4; i <= n; i++)
	{
		dp[i][0] = dp[i - 1][4] % 1000000007;
		dp[i][1] = dp[i - 2][4] % 1000000007;
		dp[i][2] = (sum + 1) % 1000000007;
		dp[i][3] = (sum + 1) % 1000000007;
		dp[i][4] = (dp[i][0] + dp[i][1] + dp[i][2] + dp[i][3]) % 1000000007;
		sum = (sum + dp[i - 2][4]) % 1000000007;
	}
	//获取答案
	ll ans = dp[n][4];
	cout << ans;
	return 0;
}

这个程序只通过了部分测试点，原因是运行内存超过限制了！

只能靠覆盖掉之前的数据来缩小数组尺寸了。

#include <iostream>
#include <algorithm>
using namespace std;
const int max_n = 1e7+2;
typedef long long ll;
ll dp[5][5];
int main() {
	int n;
	cin >> n;
	//建立初始状态
	dp[1][0] = 1;
	dp[1][1] = 0;
	dp[1][2] = 0;
	dp[1][3] = 0;
	dp[1][4] = 1;
	dp[2][0] = 1;
	dp[2][1] = 1;
	dp[2][2] = 0;
	dp[2][3] = 0;
	dp[2][4] = 2;
	dp[3][0] = 2;
	dp[3][1] = 1;
	dp[3][2] = 1;
	dp[3][3] = 1;
	dp[3][4] = 5;
	ll sum = 1;
	if (n <= 3) {
		cout << dp[n][4];
	}
	//动态规划
	for (int i = 4; i <= n; i++)
	{
		dp[4][0] = dp[3][4] % 1000000007;
		dp[4][1] = dp[2][4] % 1000000007;
		dp[4][2] = (sum + 1) % 1000000007;
		dp[4][3] = (sum + 1) % 1000000007;
		dp[4][4] = (dp[4][0] + dp[4][1] + dp[4][2] + dp[4][3]) % 1000000007;
		sum = (sum + dp[2][4]) % 1000000007;
		//更新数据
		dp[2][0] = dp[3][0];
		dp[2][1] = dp[3][1];
		dp[2][2] = dp[3][2];
		dp[2][3] = dp[3][3];
		dp[2][4] = dp[3][4];
		dp[3][0] = dp[4][0];
		dp[3][1] = dp[4][1];
		dp[3][2] = dp[4][2];
		dp[3][3] = dp[4][3];
		dp[3][4] = dp[4][4];
	}
	//获取答案
	ll ans = dp[4][4];
    if (n > 3) {
	cout << ans;
}
	return 0;
}

这道题除了动态规划外，学习到的更多是数据溢出的维护和运行内存的维护。