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

蓦然回首LookBack

已于 2024-01-31 13:42:06 修改

阅读量478

点赞数 2

分类专栏：练习日志文章标签：算法 c++ 学习

于 2024-01-31 13:32:25 首次发布

本文链接：https://blog.csdn.net/FeAtherHZM/article/details/135945849

版权

练习日志专栏收录该内容

82 篇文章

订阅专栏

文章讲述了在解决一个关于积木拼接的问题时，如何通过状态转移和动态规划的方法优化内存使用，避免整数溢出，并通过调整数组尺寸来处理大规模数据。作者分享了从二维数组到一维数组的思路转变以及数据溢出的解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述

题目思路

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

直接硬着头皮建立一维数组 $dp[i]$ ，代表长度为 $i$ 时积木的拼接方案数。假设从左往右放置积木，关注最右边的积木，容易发现最右侧的积木最多只会存在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

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

由此可以设计初始状态 $dp[i][5]$ ， $dp[i][0]$ 代表末尾为I型积木的方案数； $dp[i][1]$ 代表末尾为O型积木的方案数； $dp[i][2]$ 代表末尾为┛型积木的方案数； $dp[i][3]$ 代表末尾为┓型积木的方案数； $dp[i][4]$ 代表画布长度为 $i$ 的总方案数；

建立状态转移方程：

$dp[i][0]=dp[i-1][4]$

$dp[i][1]=dp[i-2][4]$

$dp[i][2]=dp[i][3]=\sum_{n=1}^{i-3} dp[n][4]+1$

$dp[i][4]=dp[i][0]+dp[i][1]+dp[i][2]+dp[i][3]$

我的代码

由于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;
}

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