BZOJ 1501 NOI2005 智慧珠游戏 Dancing-Links(DLX)

最新推荐文章于 2019-10-29 21:41:34 发布
最新推荐文章于 2019-10-29 21:41:34 发布
阅读量3.7k 收藏 1
点赞数 1
分类专栏： BZOJ Dancing-Links DFS 文章标签： BZOJ BZOJ1501 NOI2005 智慧珠游戏 DLX
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PoPoQQQ/article/details/39078699
版权
BZOJ 同时被 3 个专栏收录
667 篇文章 1 订阅
订阅专栏
DFS
25 篇文章 0 订阅
订阅专栏
Dancing-Links
3 篇文章 0 订阅
订阅专栏

题目大意：给定一个10*10的三角形棋盘和12种零件，每种零件只能放一次，可以旋转和翻转，一些零件已经放在了上面，求一种方案，使12个零件无重叠地放在棋盘上

首先这题目一看就是DLX 但是建图真心恶心 需要枚举每一个零件的最多八个朝向的所有位置 我一开始想要全部代码处理 但是后来发现真做不了

于是我选择了打表录入12个零件的所有60种朝向，选择第一排最左面的点作为基点，依次得出每个点关于基点的相对位置，然后再图上枚举基点的位置，若所有点都在图上就加行

一共60*5*2的表 打了40分钟 键盘被敲得噼里啪啦响 晚上还没吃饭 差点把体内(C6H12O6)n全部消耗掉0.0

这个写完之后稍微一调就过去了~ 还WA了一次，忘了输出No solution。。。。。

代码一共6.8KB 表占了很大空间 不过对比一下大牛们的代码发现我的都短了 这年这三道题真是一道比一道恶心

此外这题一共有32288种放法。。。我好无聊。。。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int top;
struct abcd *stack[40000];
struct abcd{
	abcd *l,*r,*u,*d;
	int x,y,num;
	abcd *bottom;
	abcd(abcd *L,abcd *R,abcd *U,abcd *D,int X,int Y,int Num);
	void del();
	void output();
	void restore();
}*head,*heads[100];

const int start[]={0,0,4,6,14,15,19,27,31,39,47,48,52,60};
const int size[]={0,3,4,4,4,5,5,5,5,5,5,5,5};
const int table[60][5][2]={
	
	{ {0,0} , {1,0} , {1,1} , {0,0} , {0,0} },
	{ {0,0} , {1,-1} , {1,0} , {0,0} , {0,0} },
	{ {0,0} , {0,1} , {1,0} , {0,0} , {0,0} },
	{ {0,0} , {0,1} , {1,1} , {0,0} , {0,0} },
	
	{ {0,0} , {0,1} , {0,2} , {0,3} , {0,0} },
	{ {0,0} , {1,0} , {2,0} , {3,0} , {0,0} },
	
	{ {0,0} , {0,1} , {0,2} , {1,0} , {0,0} },
	{ {0,0} , {0,1} , {1,1} , {2,1} , {0,0} },
	{ {0,0} , {1,-2} , {1,-1} , {1,0} , {0,0} },
	{ {0,0} , {1,0} , {2,0} , {2,1} , {0,0} },
	{ {0,0} , {0,1} , {1,0} , {2,0} , {0,0} },
	{ {0,0} , {0,1} , {0,2} , {1,2} , {0,0} },
	{ {0,0} , {1,0} , {2,0} , {2,-1} , {0,0} },
	{ {0,0} , {1,0} , {1,1} , {1,2} , {0,0} },
	
	{ {0,0} , {0,1} , {1,0} , {1,1} , {0,0} },
	
	{ {0,0} , {1,0} , {2,0} , {2,1} , {2,2} },
	{ {0,0} , {0,1} , {0,2} , {1,0} , {2,0} },
	{ {0,0} , {0,1} , {0,2} , {1,2} , {2,2} },
	{ {0,0} , {1,0} , {2,-2} , {2,-1} , {2,0} },
	
	{ {0,0} , {1,-2} , {1,-1} , {1,0} , {1,1} },
	{ {0,0} , {1,0} , {2,0} , {2,1} , {3,0} },
	{ {0,0} , {0,1} , {0,2} , {0,3} , {1,1} },
	{ {0,0} , {1,-1} , {1,0} , {2,0} , {3,0} },
	{ {0,0} , {1,0} , {1,1} , {2,0} , {3,0} },
	{ {0,0} , {0,1} , {0,2} , {0,3} , {1,2} },
	{ {0,0} , {1,0} , {2,-1} , {2,0} , {3,0} },
	{ {0,0} , {1,-1} , {1,0} , {1,1} , {1,2} },
	
	{ {0,0} , {0,2} , {1,0} , {1,1} , {1,2} },
	{ {0,0} , {0,1} , {1,0} , {2,0} , {2,1} },
	{ {0,0} , {0,1} , {0,2} , {1,0} , {1,2} },
	{ {0,0} , {0,1} , {1,1} , {2,0} , {2,1} },
	
	{ {0,0} , {0,1} , {1,0} , {1,1} , {2,1} },
	{ {0,0} , {0,1} , {1,-1} , {1,0} , {1,1} },
	{ {0,0} , {1,0} , {1,1} , {2,0} , {2,1} },
	{ {0,0} , {0,1} , {0,2} , {1,0} , {1,1} },
	{ {0,0} , {0,1} , {0,2} , {1,1} , {1,2} },
	{ {0,0} , {1,-1} , {1,0} , {2,-1} , {2,0} },
	{ {0,0} , {0,1} , {1,0} , {1,1} , {1,2} },
	{ {0,0} , {0,1} , {1,0} , {1,1} , {2,0} },
	
	{ {0,0} , {1,-1} , {1,0} , {2,-1} , {3,-1} },
	{ {0,0} , {0,1} , {0,2} , {1,2} , {1,3} },
	{ {0,0} , {1,0} , {2,-1} , {2,0} , {3,-1} },
	{ {0,0} , {0,1} , {1,1} , {1,2} , {1,3} },
	{ {0,0} , {0,1} , {1,-2} , {1,-1} , {1,0} },
	{ {0,0} , {1,0} , {2,0} , {2,1} , {3,1} },
	{ {0,0} , {0,1} , {0,2} , {1,-1} , {1,0} },
	{ {0,0} , {1,0} , {1,1} , {2,1} , {3,1} },
	
	{ {0,0} , {1,-1} , {1,0} , {1,1} , {2,0} },
	
	{ {0,0} , {1,0} , {1,1} , {2,1} , {2,2} },
	{ {0,0} , {0,1} , {1,-1} , {1,0} , {2,-1} },
	{ {0,0} , {0,1} , {1,1} , {1,2} , {2,2} },
	{ {0,0} , {1,-1} , {1,0} , {2,-2} , {2,-1} },
	
	{ {0,0} , {1,-3} , {1,-2} , {1,-1} , {1,0} },
	{ {0,0} , {1,0} , {2,0} , {3,0} , {3,1} },
	{ {0,0} , {0,1} , {0,2} , {0,3} , {1,0} },
	{ {0,0} , {0,1} , {1,1} , {2,1} , {3,1} },
	{ {0,0} , {0,1} , {1,0} , {2,0} , {3,0} },
	{ {0,0} , {0,1} , {0,2} , {0,3} , {1,3} },
	{ {0,0} , {1,0} , {2,0} , {3,-1} , {3,0} },
	{ {0,0} , {1,0} , {1,1} , {1,2} , {1,3} }
};
int map[11][11],repos[11][11],cnt=12;
bool appeared[13],mark[11][11];

void DLX();
void output();
void find(int p);
inline char getnum();
void del_row(abcd *pos);
void add(int p,int pos);
void del_column(abcd *pos);

int main()
{
	int i,j;
	abcd *last;
	head=new abcd(0x0,0x0,0x0,0x0,0,0,0);
	for(last=head,i=1;i<=67;i++)
		last=new abcd(last,0x0,0x0,0x0,0,0,0),heads[i]=last;
	
	for(i=1;i<=10;i++)
		for(j=1;j<=i;j++)
			repos[i][j]=++cnt,map[i][j]=getnum();
	
	for(i=1;i<=12;i++)
		if(!appeared[i])
			for(j=start[i];j!=start[i+1];j++)
				add(i,j);
		else
			find(i);
	DLX();
	puts("No solution");
	return 0;
}

abcd :: abcd(abcd *L,abcd *R,abcd *U,abcd *D,int X,int Y,int Num)
{
	l=L;if(L)L->r=this;
	r=R;if(R)R->l=this;
	u=U;if(U)U->d=this;
	d=D;if(D)D->u=this;
	x=X;y=Y;num=Num;
	bottom=d;
	if(bottom)
		bottom->x++;
}
void abcd :: del()
{
	if(l)l->r=r;
	if(r)r->l=l;
	if(u)u->d=d;
	if(d)d->u=u;
	if(bottom)
		bottom->x--;
	stack[++top]=this;
}
void abcd :: restore()
{
	if(l)l->r=this;
	if(r)r->l=this;
	if(u)u->d=this;
	if(d)d->u=this;
	if(bottom)
		bottom->x++;
}
void output()
{
	int i,j;
	for(i=1;i<=10;i++)
	{
		for(j=1;j<=i;j++)
			putchar(map[i][j]+'A'-1);
		putchar('\n');
	}
}
void del_column(abcd *pos)
{
	abcd *temp1,*temp2;
	for(temp1=pos->u;temp1;temp1=temp1->u)
	{
		for(temp2=temp1->l;temp2;temp2=temp2->l)
			temp2->del();
		for(temp2=temp1->r;temp2;temp2=temp2->r)
			temp2->del();
		temp1->del();
	}
	pos->del();
}
void del_row(abcd *pos)
{
	if(!pos)
		return ;
	del_row(pos->r);
	del_column(pos->bottom);
	int x=pos->x,y=pos->y,num=pos->num;
		map[x][y]=num;
}
void DLX()
{
	if(!head->r)
	{
		output();
		exit(0);
	}
	int bottom=top,minnum=0x7fffffff;
	abcd *temp,*mintemp;
	for(temp=head->r;temp;temp=temp->r)
		if(temp->x<minnum)
			minnum=temp->x,mintemp=temp;
	for(temp=mintemp->u;temp;temp=temp->u)
	{
	
		for(mintemp=temp;mintemp->l;mintemp=mintemp->l);
		del_row(mintemp);
		
		DLX();
		while(top!=bottom)
			stack[top--]->restore();
	}
}
inline char getnum()
{
	char c;
	do c=getchar(); while(c==' '||c=='\n'||c=='\r');
	if(c=='.')
		return 0;
	appeared[c-'A'+1]=1;
	return c-'A'+1;
}
void add(int p,int pos)
{
	int i,j,k,x,y;
	for(i=1;i<=10;i++)
		for(j=1;j<=i;j++)
		{
			for(k=0;k<size[p];k++)
			{
				x=i+table[pos][k][0];
				y=j+table[pos][k][1];
				if(x>0&&y>0&&x<=10&&y<=x);
				else
					break;
			}
			if(k==size[p])
			{
				abcd *last,*temp;
				temp=heads[ p ];
				last = new abcd(0x0,0x0,temp->u,temp,0,0,0);
				for(k=0;k<size[p];k++)
				{
					x=i+table[pos][k][0];
					y=j+table[pos][k][1];
					temp=heads[ repos[x][y] ];
					last = new abcd(last,0x0,temp->u,temp,x,y,p);
				}
			}
		}
}
void find(int p)
{
	int i,j;
	abcd *last,*temp;
	temp=heads[ p ];
	last = new abcd(0x0,0x0,temp->u,temp,0,0,0);
	for(i=1;i<=10;i++)
		for(j=1;j<=i;j++)
			if(map[i][j]==p)
				temp=heads[ repos[i][j] ],last = new abcd(last,0x0,temp->u,temp,i,j,p);
}


PoPoQQQ
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
[DLX] [NOI2005] 智慧珠游戏
drj
09-24 1202
具体题目详见 NOI2005 第一试试题。 这显然是一个 NP 问题。怎么做呢？答案很明显，搜索。 说到搜索，这道题所要求的并不是最优解，也不是方案数，而且数据保证如果有解则只有一组解。 然后再对照这个题目：用所有的“智慧珠”来填满棋盘中每一个空。 想到了什么？对，精确覆盖模型。用每一个智慧珠和棋盘中的每一空为列，以智慧珠翻转和旋转所得的 60 个形态在每一个位置上的填补为行，即可。 顺
【BZOJ】1500: [NOI2005]维修数列-splay
远行客
12-05 142
splay模板
BZOJ1501 (NOI2005 智慧珠游戏）
weixin_33985507的博客
10-07 130
传送门@百度 1501: [NOI2005]智慧珠游戏 Time Limit:5 SecMemory Limit:64 MB Description Input 文件中包含初始的盘件描述，一共有10行，第i行有i个字符。如果第i行的第j个字符是字母”A”至”L”中的一个，则表示第i行第j列的格子上已经放了零件，零件的编号为对应的字母。如果第i行的第j个...
【BZOJ1501】【NOI2005】智慧珠游戏（搜索）
小蒟蒻yyb的博客
02-27 423
[BZOJ1501][NOI2005]智慧珠游戏（搜索）题面我要一改我懒惰的作风这道题目必须放题面DescriptionInput文件中包含初始的盘件描述，一共有10行，第i行有i个字符。如果第i行的第j个字符是字母”A”至”L”中的一个，则表示第i行第j列的格子上已经放了零件，零件的编号为对应的字母。如果第i行的第j个字符是”.”，则表示第i行第j列的格子上没有放零件。输入保证预放的零件已摆放在盘
BZOJ 1501([NOI2005]智慧珠游戏-DLX)
nike0good |Oier&ACMer | 熟能生巧
07-14 803
DLX，但是要考虑12个模型4种旋转是否镜像12*4*2种情况放在55个位置的情况，还有剪枝删除一些没用的 MLE卡了半天……考场上要哭晕 #include<bits/stdc++.h> using namespace std; #define For(i,n) for(int i=1;i<=n;i++) #define Fork(i,k,n) for(int i=k;i<=n;i++) #def
【搜索】【NOI2005】智慧珠游戏
void* ptr = &OI;
06-03 1061
【输入格式】 文件中包含初始的盘件描述,一共有 10 行,第 i 行有 i 个字符。如果第 i 行的第 j 个字符是字母”A”至”L”中的一个,则表示第 i 行第 j 列的格子上已经放了零件,零件的编号为对应的字母。如果第 i 行的第 j 个字符是”.”,则表示第 i 行第 j 列的格子上没有放零件。 输入保证预放的零件已摆放在盘件中。 【输出格式】 如果能找到解,向输出文件打印 10 行,为放完
wangjunrui666#bzoj-problem##3240. [Noi2013]矩阵游戏1
07-25
她生成的这个矩阵满足一个神奇的性质：若用F[i][j]来表示矩阵中第i行第j列的元素，则F[i][j]满足下面的递推式:递推式中a,b,c,d都是给定的常数。由
wangjunrui666#bzoj-problem##3255. 一个关于序列的游戏1
07-25
第一行一个整数N，表示序列长度 第二行N个数，V1、V2VN，代表每个长度对应的分数 第三行N个数，A1、A2AN，代表初始序列的每个元素
BZOJ1500: [NOI2005]维修数列（洛谷P2042）
forezxl的博客
12-09 339
Splay
wangjunrui666#bzoj-problem##2319. 黑白棋游戏1
07-25
第一行一个数N 第二行N个数，第i个数表示第i个01序列中黑棋的个数 第三行N个数，第i个数表示第i个01序列中白棋的个数
dancing links 骑士遍历
07-10
dancing links 解决骑士遍历问题，实验报告，含源代码
智慧拼珠求解及智慧金字塔求解
07-14
智慧珠的回溯 法求解及dancinglink求解，智慧金字塔的dancinglink求解法
智慧珠游戏
iunknown
02-09 531
过年买了个 智慧珠 游戏盒，在玩高级题的时候，有一半没过关，就想能不能用程序来暴力破解。刚才终于写了这个程序出来，已经可以在全空的棋盘上靠暴力穷举出一个答案出来了。 下一步再修改为可以用来解题。 题目的详细说明：[url]http://oi.tju.edu.cn/problem/view/1028.html[/url] [code] loop 682 board B B ...
bzoj 2706: [SDOI2012]棋盘覆盖 Dancing Link
alex151194310的博客
01-14 155
2706: [SDOI2012]棋盘覆盖 Time Limit: 10 SecMemory Limit: 256 MBSubmit: 255Solved: 77[Submit][Status] Description 在一个N*M个方格组成的棋盘内，有K个方格被称为特殊方格。我们要使用一组俄罗斯方块来覆盖这个棋盘，保证特殊方格不能被覆盖，非特殊方格只能被一个俄罗斯方...
【NOI2005】智慧珠游戏，DLX的NOIP坎关。
辗转山河弋流歌
10-31 2299
NOI2005三大神题之“智慧珠游戏”， 你说没有5K搞不出来？那你打的是什么破表啊？ 你不相信？那快来看看我的12行小短表吧。
【NOI2005】 智慧珠游戏
06-03 594
题目描述 智慧珠游戏 【问题描述】 智慧珠游戏拼盘由一个三角形盘件和 12 个形态各异的零件组成。拼盘的盘 件如图 1 所示: 图1 12 个零件按珠子数分 3 大类: 第 1 大类,有三个珠子,只有一种形状。 符号为 A,形状为 第 2 大类,有 4 个珠子,有 3 种形状。 符号为 B,形状为 符号为 C,形状为 符号为 D,形状为 第 3 大类,有...
Bzoj1501: [NOI2005]智慧珠游戏
Cyhlnj
02-27 234
题面 Bzoj 我写这篇题解的原因 证明我是一个有耐心的人 Sol 爆搜 先判断有没有小于三的联通块 然后ACACAC 其实不用像我这样打的 主要是打了一半时发现可以打个表循环找，然而打了一半，所以就只写了20k20k20k(逃 其实也就写了不到一个小时 其实也就调了几分钟 。。。 。。。 。。。 我代码又臭又长被关了起来 # include &lt;bit...
【洛谷P4205】智慧珠游戏【dfs】
stoorz
10-29 1235
题目大意： 题目链接：https://www.luogu.org/problem/P4205 智慧珠游戏拼盘由一个三角形盘件和 12 个形态各异的零件组成。拼盘的盘 件如图 1 所示 可以放到盘件的任一位置，条件是能有地方放，且 尺寸合适，所有的零件都允许旋转(0º、90º、180º、270º)和翻转(水平、竖直)。 现给出一个盘件的初始布局，求一种可行的智慧珠摆放方案，使所有的零件 都能放...
【算法杂谈】Dancing Link
04-07 1411
Dancing Link是解决精确覆盖问题的最有效方法之一。精确覆盖问题：给定一个由0和1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1？ 例如，下面这个矩阵 就包含了这样一个集合（第1，4，5行）。我们把列想象成全集的一些元素，而行看作全集的一些子集；或者我们可以把行想象成全集的一些元素，而把列看作全集的一些子集；那么这个问题就是要求寻找一批元素，它们与每个子集恰好有一个
BZOJ JOI 2013-2014春季训练合宿题目解析1
"BZOJ JOI 2013~2014 春季training合宿 系列题解1" 这篇题解涉及到的是一个编程竞赛中的题目，主要运用了哈希算法来解决。哈希算法在计算机科学中是一种高效的数据结构和算法，它能够快速查找、插入和删除元素，其...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值