CCF2014年9月试题5 搭积木问题

最新推荐文章于 2022-03-26 15:34:40 发布
最新推荐文章于 2022-03-26 15:34:40 发布
阅读量1.7w 收藏 1
点赞数 1
分类专栏： ACM 算法导论（算法实现c/c++版） 文章标签： 搭积木问题 CCF2014年9月 给出一个n-m的方格 L型的积木
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011889952/article/details/54099995
版权

试题信息：

限制和要求：

限制于要求信息
时间限制：3.0s
内存限制：256.0MB

问题描述：

给出一个n×m的方格图，现在要用如下L型的积木拼到这个图中，使得方格图正好被拼满，请问总共有多少种拼法。其中，方格图的每一个方格正好能放积木中的一块。积木可以任意旋转。
小积木的形状

输入格式

输入的第一行包含两个整数n, m，表示方格图的大小。
输出格式
　　输出一行，表示可以放的方案数，由于方案数可能很多，所以请输出方案数除以1,000,000,007的余数。
样例输入

6 2

样例输出

4

样例说明

四种拼法如下图所示：
四种搭配方式

评测用例规模与约定

在评测时将使用10个评测用例对你的程序进行评测。
　　评测用例1和2满足：1<=n<=30，m=2。
　　评测用例3和4满足：1<=n, m<=6。
　　评测用例5满足：1<=n<=100，1<=m<=6。
　　评测用例6和7满足：1<=n<=1000，1<=m<=6。
　　评测用例8、9和10满足：1<=n<=10^15，1<=m<=7。

解决方案

初步拿到这道题的时候，有点棘手，其实仔细想想可以将问题划分成两个部分，第一部分就是推测状态的转移，第二部分就是计算状态邻接矩阵。

状态转移

题目中实际上是一个状态转移的计算，我们将每个方格看成一个二进制的数的话，以7个方格为例说明，也就是状态0（0000000）到0x7F（1111111）之间的这些状态的相互转换，转换的规则如下：
　　
　　填完第一行后，line2达到状态复制给line1，然后line3的状态复制给line2，由于line3的状态肯定是全空（全新的一个状态，考虑到上面四种模型最多只能填充两行，因此下一行肯定是空的），就可以进行下一轮的迭代了。
　　
　　由此我们就可以首先计算任意两个状态line1，line2（line1是一个00-7F之间的一个随机状态，line2是line1经过四种填充后到达的一个状态），这里计算出任意两个状态之间进行一步转移的邻接矩阵设为A。

状态转移叠加

既然上述步骤计算出了状态转移矩阵A，下面就是计算A^(n-1)。
　　考虑到n有可能是很大的整数（10^15），因此使用普通的矩阵计算方法肯定会超时，这里使用快速幂的方法进行矩阵运算。

以上就是我的思路，下面附上我实现的代码，很可惜在小数据的时候通过了，在跑最后一个测试用例时，没通过，问题还没解决，所以下面的代码理论上还是有问题的，希望能与各位交流。

参考源码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>


#define M 1000000007
//#define __DEBUG__  1


unsigned int matrix[128][128] = {0};
int Mval = 0;


int getposition(char a)
{
	int index = 0;
	for (index = 0; index < Mval; index++)
		if ((a & (1 << index)) == 0)
			return index;
	return index;
}

void getnext(char nnn, char input, char output, int blocks)
{
	int index = getposition(input);
	if (index >= Mval)
	{
//		printf("arrival%x %x %x\n", nnn, input, output);
//		matrix[nnn][0]=1;
		return;
	}
	switch (blocks)
	{
	case 1:
		// xx
		// x
		if (index >= (Mval - 1) || (input & (1 << (index + 1))) || (output & (1 << index))) //unreachable
			return ;
		input += ((1 << index) + (1 << (index + 1)));
		output += (1 << index);
		if (input == ((1 << Mval) - 1)) //到达一个可行状态,删除一个可行状态，进行下一步迭代
		{
#if __DEBUG__
			printf("reachalbe from %x to %x\n", nnn, output);
#endif
			matrix[nnn][output] = (matrix[nnn][output] + 1) % M;
			return ;
		}
		getnext(nnn, input, output, 1);
		getnext(nnn, input, output, 2);
		getnext(nnn, input, output, 3);
		getnext(nnn, input, output, 4);
		break;
	case 2:
		// xx
		//  x
		if (index >= (Mval - 1) || (input & (1 << (index + 1))) || (output & (1 << (index + 1)))) //unreachable
			return ;
		input += ((1 << index) + (1 << (index + 1)));
		output += (1 << (index + 1));
		if (input == ((1 << Mval) - 1)) //到达一个可行状态,删除一个可行状态，进行下一步迭代
		{
#if __DEBUG__
			printf("reachalbe from %x to %x\n", nnn, output);
#endif
			matrix[nnn][output] = (matrix[nnn][output] + 1) % M;
			return ;
		}
		getnext(nnn, input, output, 1);
		getnext(nnn, input, output, 2);
		getnext(nnn, input, output, 3);
		getnext(nnn, input, output, 4);
		break;
	case 3:
		// x
		// xx
		if (index >= (Mval - 1) || (output & (1 << (index + 1))) || (output & (1 << index))) //unreachable
			return ;
		input += ((1 << index));
		output += ((1 << index) + (1 << (index + 1)));
		if (input == ((1 << Mval) - 1)) //到达一个可行状态,删除一个可行状态，进行下一步迭代
		{
#if __DEBUG__
			printf("reachalbe from %x to %x\n", nnn, output);
#endif
			matrix[nnn][output] = (matrix[nnn][output] + 1) % M;
			return ;
		}
		getnext(nnn, input, output, 1);
		getnext(nnn, input, output, 2);
		getnext(nnn, input, output, 3);
		getnext(nnn, input, output, 4);
		break;
	case 4:
		// x
		//xx
		if (index == 0 || (output & (1 << (index - 1))) || (output & (1 << (index)))) //unreachable
			return ;
		input += (1 << index);
		output += ((1 << index) + (1 << (index - 1)));
		if (input == ((1 << Mval) - 1)) //到达一个可行状态,删除一个可行状态，进行下一步迭代
		{
#if __DEBUG__
			printf("reachalbe from %x to %x\n", nnn, output);
#endif
			matrix[nnn][output] = (matrix[nnn][output] + 1) % M;
			return ;
		}
		getnext(nnn, input, output, 1);
		getnext(nnn, input, output, 2);
		getnext(nnn, input, output, 3);
		getnext(nnn, input, output, 4);
		break;
	default:
		break;
	}
	return ;
}


void initstates(void)
{
	int index = 0;
	int loops = (1 << Mval);
	for (index = 0; index < loops; index++)
	{
		getnext(index, index, 0, 1);
		getnext(index, index, 0, 2);
		getnext(index, index, 0, 3);
		getnext(index, index, 0, 4);
	}
	matrix[index - 1][0] = 1;
	return ;

}

void printmatrix(unsigned int matrix[][128])
{
	int ral, cow;
	printf("   ");
	for (cow = 0; cow < (1 << Mval); cow++)
		printf("|%.3x", cow);
	printf("\n");
	for (ral = 0; ral < (1 << Mval); ral++)
	{
		printf("%.3x", ral);
		for (cow = 0; cow < (1 << Mval); cow++)
			if (matrix[ral][cow] == 0)
				printf("|   ");
			else
				printf("|%.3d", matrix[ral][cow]);
		printf("\n");
	}
}

void FastExponentiation(unsigned int src[][128], unsigned int results[][128], long long times)
{
	if (times == 0)return;
	if (times == 1)
	{
		memcpy(results, src, sizeof(unsigned int) * 128 * 128);
		return;
	}
	unsigned int sss[128][128] = {0};
	long long temp = 0;
	FastExponentiation(src, sss, times / 2);
	int i, j, k;
	for (i = 0; i < (1 << Mval); i++)
		for (j = 0; j < (1 << Mval); j++)
			for (k = 0; k < (1 << Mval); k++)
			{
				temp = (long long)sss[i][k] * sss[k][j];
				results[i][j] += (temp % M) ;
				results[i][j] %= M;
			}
#if __DEBUG__
	printf("        cccccc %d\n\n\n", times);
	printmatrix(sss);
	printmatrix(results);
	printf("        cccccc\n\n\n");
#endif // __DEBUG__
	if (times % 2)
	{
		memcpy(sss, results, sizeof(unsigned int) * 128 * 128);
		memset(results, 0, sizeof(unsigned int) * 128 * 128);
		for (i = 0; i < (1 << Mval); i++)
			for (j = 0; j < (1 << Mval); j++)
				for (k = 0; k < (1 << Mval); k++)
				{
					temp = (long long)sss[i][k] * src[k][j];
					results[i][j] += (temp % M);
					results[i][j] %= M;
				}
	}
#if __DEBUG__
	printmatrix(sss);
	printmatrix(results);
#endif // __DEBUG__
	return ;

}

void FastExponentiation2(unsigned int src[][128], unsigned int results[][128], long long times)
{
	unsigned int s1[128][128] = {0};
	unsigned int s2[128][128] = {0};
	unsigned int s3[128][128] = {0};
	long long temp = 0;
	int i, j, k;
	for (i = 0; i < 128; i++)results[i][i] = 1;
//    printmatrix(results);
	memcpy(s1, src, sizeof(unsigned int) * 128 * 128);
	while (times)
	{
//        printmatrix(s1);
		memset(s2, 0, sizeof(unsigned int) * 128 * 128);
		if (times & 1)
		{
			memcpy(s3, results, sizeof(unsigned int) * 128 * 128);
			memset(results, 0, sizeof(unsigned int) * 128 * 128);
//           printmatrix(s3);
			for (i = 0; i < (1 << Mval); i++)
				for (j = 0; j < (1 << Mval); j++)
					for (k = 0; k < (1 << Mval); k++)
					{
						temp = (long long)s3[i][k] * s1[k][j];
						results[i][j] += (temp % M) ;
						results[i][j] %= M;
					}
		}
//       printmatrix(results);
		times = times >> 1;
		for (i = 0; i < (1 << Mval); i++)
			for (j = 0; j < (1 << Mval); j++)
				for (k = 0; k < (1 << Mval); k++)
				{
					temp = (long long)s1[i][k] * s1[k][j];
					s2[i][j] += (temp % M) ;
					s2[i][j] %= M;
				}
		memcpy(s1, s2, sizeof(unsigned int) * 128 * 128);
	}
	return ;

}

//#define __DEBUG__ 1
int main(int argc, char* argv[])
{
//    freopen("out.txt", "w", stdout);
	int m;
	long long n;
	unsigned int sss[128][128] = {0};

	scanf("%lld%d", &n, &m);
	Mval = m;
	initstates();
#if __DEBUG__
	printmatrix(matrix);
	printf("\n\n\n");
	system("pause");
#endif
//   FastExponentiation(matrix,sss,n-1);
//    printf("%d\n",sss[0][(1<<m)-1]);
	memset(sss, 0, sizeof(unsigned int) * 128 * 128);
	FastExponentiation2(matrix, sss, n - 1);
	printf("%d\n", sss[0][(1 << m) - 1]);
#if __DEBUG__
	printmatrix(sss);
	printf("\n\n\n");
	int j = 2;
	for (j = 2; j <= n; j++)
	{
		memset(sss, 0, sizeof(unsigned int) * 128 * 128);
		printf("\n\n%d\n", j);
		FastExponentiation(matrix, sss, j - 1);
		printmatrix(sss);
	}
#endif
	return 0;
}

终于在网上找到正确的解法了，如下所示：

//ref:http://blog.csdn.net/vcvycy/article/details/78243162
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
#define MOD 1000000007
#define MM 7
int a[1 << MM][1 << MM];
long long n;
int m;
#define VACANT(S,u) (u>=0 && u<m && ((S&(1<<u))==0))
int SETADD(int S, int u1, int u2 = -1)
{
	S |= 1 << u1;
	if (u2 != -1) S |= 1 << u2;
	return S;
}
int c[1 << MM][1 << MM];
void mat_mul(int a[][1 << MM], int b[][1 << MM], int sz = 1 << m)
{
	memset(c, 0, sizeof(c));
	for (int i = 0; i < sz; i++)
		for (int j = 0; j < sz; j++)
			for (int k = 0; k < sz; k++)
			{
				c[i][j] = (c[i][j] + 1ll * a[i][k] * b[k][j]) % MOD;
			}
	for (int i = 0; i < sz; i++)
		for (int j = 0; j < sz; j++)
			a[i][j] = c[i][j];
}
void search(int originS, int S1, int S2 = 0)
{
	//printf("S1=%d,S2=%d\n",S1,S2);
	if (S1 == (1 << m) - 1)
	{
		//printf("%d->%d +1\n",originS,S2);
		a[originS][S2]++;
		return ;
	}
	for (int i = 0; i < m; i++) //找到第一个没被占用的格子，然后继续搜索
		if (VACANT(S1, i))       //格子i没有被占用
		{
			//(1) 2 1(down)
			if (VACANT(S1, i + 1) && VACANT(S2, i + 1))
			{
				search(originS, SETADD(S1, i, i + 1), SETADD(S2, i + 1));
			}
			//(2) 2 1(up)
			if (VACANT(S1, i + 1) && VACANT(S2, i))
				search(originS, SETADD(S1, i, i + 1), SETADD(S2, i));
			//(3) 1 2(up)
			if (VACANT(S2, i) && VACANT(S2, i - 1))
				search(originS, SETADD(S1, i), SETADD(S2, i - 1, i));
			//(4) 1 2(down)
			if (VACANT(S2, i) && VACANT(S2, i + 1))
				search(originS, SETADD(S1, i), SETADD(S2, i, i + 1));
			break;
		}
}
#define FOR0(i,n) for (int i=0;i<n;i++)
int ans[1 << MM][1 << MM];
int main()
{
	cin >> n >> m;
	memset(a, 0, sizeof(a));
	for (int S = 0; S < (1 << m); S++) search(S, S);
	int matsz = (1 << m);
	FOR0(i, matsz) FOR0(j, matsz) ans[i][j] = (i == j) ? 1 : 0;
	//矩阵快速幂 ans=a^(n-1)
	long long b = n - 1;
	while (b)
	{
		if (b & 1) mat_mul(ans, a);
		mat_mul(a, a);
		b >>= 1;
	}
	printf("%d\n", ans[0][matsz - 1]);
	return 0;
}
尼奥普兰
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
ccf.rar_ccf试题
09-20
CCF考试题17年9月和12月的第二题，钥匙串的实现以及游戏。
蓝桥杯【第13届省赛】Python 实现
荷碧TongZJ 的水文
06-03 5396
这个题集涵盖了第十三届省赛所有组别的编程题，但 Python B 组的题解我写在了另一篇文章中：蓝桥杯【第13届省赛】Python B组 98.95分 测试链接：https://www.dotcpp.com/oj/train/1023/
MySQL笔记(一)SQL基础
-
03-26 2761
SQL 数据定义语言（Data Definition Language，DDL） 用来创建或删除数据库以及表等对象，主要包含以下几种命令： DROP：删除数据库和表等对象 CREATE：创建数据库和表等对象 ALTER：修改数据库和表等对象的结构 数据操作语言（Data Manipulation Language，DML） 用来变更表中的记录，主要包含以下几种命令： SELECT：查询表中的数据 INSERT：向表中插入新数据 UPDATE：更新表中的数据 DELETE：删除表中的数据 数据查询语言
《失控》
每一个不曾起舞的日子，都是对人生的辜负。
04-01 3万+
人造与天生 新生物文明 造化所生的自然王国和人类建造的人造国度正在融为一体。机器，正在生物化；而生物，正在工程化。这种趋势正验证着某些古老的隐喻——将机器比喻为生物，将生物比喻为机器。如今，那些久远的隐喻不再只是诗意的遐想，它们正在变成现实。 由于我们自己创造的这个世界变得过于复杂，我们不得不求助于自然世界以了解管理它的方法。这也就意味着，想要保证一切正常运转，我们最终制造出来的环境越机械化，可能...
「树莓派+1万块乐高」打造乐高分类器，树莓派官方转发，网友：我想借来用两天...
量子位
01-20 381
晓查 发自 凹非寺量子位 报道 | 公众号 QbitAI拼乐高最头疼的问题是什么？当然是苦苦寻找某个形状的积木却找不到。当你兴致勃勃地打开包装时，眼前的一切却是这样，内心会作何感想？现...
搭积木
树新风的博客
03-29 1109
搭积木 小明最近喜欢搭数字积木， 一共有10块积木，每个积木上有一个数字，0~9。 搭积木规则： 每个积木放到其它两个积木的上面，并且一定比下面的两个积木数字小。 最后搭成4层的金字塔形，必须用完所有的积木。 下面是两种合格的搭法： 0 1 2 3 4 5 6 7 8 9 0 3 1 7 5 2 9 8 6 4 请你计算这样的搭法一共有多少种？ 请...
搭积木问题
qq_42254419的博客
05-12 1622
搭积木问题 题目描述： 小明最近喜欢搭数字积木。一共有10块积木，每个积木上有一个数字，0~9。 搭积木规则： 每个积木放到其它两个积木的上面，并且一定比下面的两个积木数字小。 最后搭成4层的金字塔形，必须用完所有的积木。 下面是两种合格的搭法： 0 1 2 3 4 5 6 7 8 9 0 3 1 7 5 2 9 8 6 4 请你计算这样的搭法一共有多少种？ 算法分析： 首先题目只说有10块积木，对于这种小规模的数据不需要考虑太多块积木的情况，我们就写10块...
蓝桥杯-搭积木问题
dielou5641的博客
03-16 188
问题描述： 小明最近喜欢搭数字积木。一共有10块积木，每个积木上有一个数字，0~9。搭积木规则：每个积木放到其它两个积木的上面，并且一定比下面的两个积木数字小。最后搭成4层的金字塔形，必须用完所有的积木。下面是两种合格的搭法： 0 1 23 4 56 7 8 9 0 3 17 5 29 8 6 4 请你计算这样的搭法一共有多少种？ 问题分析： 这道题目，其实我...
蓝桥杯搭积木问题DFS
qq_37432444的博客
02-01 1814
小明最近喜欢搭数字积木， 一共有10块积木，每个积木上有一个数字，0~9。 搭积木规则： 每个积木放到其它两个积木的上面，并且一定比下面的两个积木数字小。 最后搭成4层的金字塔形，必须用完所有的积木。下面是两种合格的搭法： 0 1 2 3 4 5 6 7 8 90 3 1 7 5 2 9 8 6 4 请你计算这样的搭法一共有多少种？ 请填表示总数目的数字。#include
问题F：搭积木的诀窍
qq_20751233的博客
12-02 509
                                  问题F：搭积木的诀窍 时间限制：1秒内存限制：128 MB 提交：721解决：386 [ 提交 ] [ 状态 ] [ 讨论版 ] [命题人：admin ] 题目描述 小Q的编程技术在一次搭积木比赛中也成了秘密武器原来，比赛的规则是这样的：给你Ñ个小木块（全部为一样大小的正方体），快速搭成如下图规则的形状（下图为5层的规模）...
CCF 2014年12月第二题
07-12
问题描述 在图像编码的算法中,需要将一个给定的方形矩阵进行Z字形扫描(Zigzag Scan)。给定一个n×n的矩阵,Z字形扫描的过程如下图所示: 对于下面的4×4的矩阵, 1539 3756 9464 7313 对其进行Z字形扫描后得到长度为16...
2014年9月份CCF考试真题及答案
12-02
2014年9月份CCF考试真题及答案，希望对大家有帮助。
2013-2017年CCF试题C++程序代码
07-25
该资源包含了2013-2017年CCF试题的C++程序代码，要考CCF的童鞋请积极下载哦！
整数拆分问题的四种解法
热门推荐
NEWPLAN的专栏
04-01 12万+
整数划分问题是算法中的一个经典命题之一 所谓整数划分，是指把一个正整数n写成如下形式： n=m1+m2+m3+....+mi;（其中mi为正整数，并且1&lt;=mi&lt;=n），则{m1,m2,m3,....,mi}为n的一个划分。 如果{m1,m2,m3,....,mi}中的最大值不超过m，即max{m1,m2,m3,....,mi} &lt;= m，则称它属于n的一个m划分。这...
堆排序
NEWPLAN的专栏
03-23 5万+
堆排序是一种选择排序，其时间复杂度为O(nlogn)。 堆的定义 　　n个元素的序列{k1，k2，…,kn}当且仅当满足下列关系之一时，称之为堆。 　　情形1：ki 2i 且ki 2i+1 （最小化堆或小顶堆） 　　情形2：ki >= k2i 且ki >= k2i+1 （最大化堆或大顶堆） 　　其中i=1,2,…,n/2向下取整;        
农夫过河问题算法设计与实现
NEWPLAN的专栏
04-01 3万+
农夫过河算法基于队列的实现
迷宫问题算法设计与实现
NEWPLAN的专栏
04-01 2万+
迷宫问题算法的实现（基于队列版本和回朔法版本）
ccf gesp 6月认证 四级 试题
最新发布
11-22
六月的CCF GESP四级认证考试试题主要涵盖了计算机科学的基础知识、数据结构与算法、软件工程、数据库原理、网络技术等方面的内容。考试题型包括单选题、多选题、判断题和简答题等多种形式，旨在全面考察考生的计算机科学知识水平和解决实际问题的能力。 在单选题部分，考生需要根据题干提供的情境或问题选择最适合的答案，考察考生对知识点的理解和应用能力；多选题部分则要求考生综合考虑多个因素，选出符合题意的所有答案；判断题部分考察考生对知识点的辨别能力，要求准确判断给定命题的真假；简答题则需要考生结合自身的学习和实践经验，对具体问题进行阐述和解答。 总体而言，CCF GESP四级认证考试试题注重对考生综合能力的考察，在知识量和难度上都有一定挑战，通过考试不仅可以检验考生的理论知识水平，还可以考察其解决实际问题的能力。因此，备考考生需要系统复习计算机科学的相关知识，注重知识的整合和应用，灵活运用所学知识解决各类问题，全面提升自己的综合能力。同时，对于每一个知识点都要有清晰的理解和掌握，并在平时的学习中不断进行实践与总结，以达到更好的备考效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值