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

题目大意:给定一个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);
}
时间: 2024-10-05 22:07:41

BZOJ 1501 NOI2005 智慧珠游戏 Dancing-Links(DLX)的相关文章

bzoj 1501: [NOI2005]智慧珠游戏 Dancing Link

1501: [NOI2005]智慧珠游戏 Time Limit: 5 Sec  Memory Limit: 64 MBSubmit: 190  Solved: 122[Submit][Status] Description Input 文件中包含初始的盘件描述,一共有10行,第i行有i个字符.如果第i行的第j个字符是字母”A”至”L”中的一个,则表示第i行第j列的格子上已经放了零件,零件的编号为对应的字母.如果第i行的第j个字符是”.”,则表示第i行第j列的格子上没有放零件.输入保证预放的零件已

bzoj1501: [NOI2005]智慧珠游戏 dancing links

精确覆盖问题,用dancing links求解. 打常量表比较麻烦. #include<bits/stdc++.h> #define FOR(i,s,t)for(node* i=(s)->t;i!=(s);i=i->t) const int f[60][12]={ {0,3,0,0,0,1,1,0}, {0,3,0,0,0,1,1,1}, {0,3,0,0,1,0,1,1}, {0,3,0,1,1,0,1,1}, {1,4,0,0,0,1,0,2,0,3}, {1,4,0,0,1,

BZOJ1501 (NOI2005 智慧珠游戏)

传送门@百度 1501: [NOI2005]智慧珠游戏 Time Limit: 5 Sec  Memory Limit: 64 MB Description Input 文件中包含初始的盘件描述,一共有10行,第i行有i个字符.如果第i行的第j个字符是字母”A”至”L”中的一个,则表示第i行第j列的格子上已经放了零件,零件的编号为对应的字母.如果第i行的第j个字符是”.”,则表示第i行第j列的格子上没有放零件.输入保证预放的零件已摆放在盘件中. Output 如果能找到解,向输出文件打印10行,

[BZOJ1501][NOI2005] 智慧珠游戏

Input 文件中包含初始的盘件描述,一共有10行,第i行有i个字符.如果第i行的第j个字符是字母”A”至”L”中的一个,则表示第i行第j列的格子上已经放了零件,零件的编号为对应的字母.如果第i行的第j个字符是”.”,则表示第i行第j列的格子上没有放零件.输入保证预放的零件已摆放在盘件中. Output 如果能找到解,向输出文件打印10行,为放完全部12个零件后的布局.其中,第i行应包含i个字符,第i行的第j个字符表示第i行第j列的格子上放的是哪个零件.如果无解,输出单独的一个字符串‘No so

BZOJ 1501 智慧珠游戏

Description Input 文件中包含初始的盘件描述,一共有10行,第i行有i个字符.如果第i行的第j个字符是字母”A”至”L”中的一个,则表示第i行第j列的格子上已经放了零件,零件的编号为对应的字母.如果第i行的第j个字符是”.”,则表示第i行第j列的格子上没有放零件.输入保证预放的零件已摆放在盘件中. Output 如果能找到解,向输出文件打印10行,为放完全部12个零件后的布局.其中,第i行应包含i个字符,第i行的第j个字符表示第i行第j列的格子上放的是哪个零件.如果无解,输出单独

【NOI2005】智慧珠游戏,DLX的NOIP坎关。

这道题会做了,NOIP就出什么DLX都不怕了,注意:是NOI"P". 题意:有12个块,可以任意翻转.旋转,即每个块最多有8种表现形式.现在要求你把它们填进图中. 注:每个块只能用一次. DLX建图:列55+12,行若干. 当然,我是会给你算好的数据的. #define N 3000/*每个块"8"种形状就会有2730行*/ #define M 70/*55+12这么多列*/ #define NN 16000/*空图最多15084个点*/ 前55列表示位置,每个位置

POJ 2676 Sudoku (搜索,Dancing Links)

题目: http://poj.org/problem?id=2676 题意: 数独,每行1-9,每列1-9,每3*3小格1-9,填数,不能重复 方法:Dancing Links(16ms)或者DFS暴搜(400-900ms) Dancing Links(DLX) 是为了解决矩阵精确覆盖问题的算法,算法效率非常高 使用DLX解决的问题必须转化为矩阵精确覆盖问题: 1.DLX详解: http://wenku.baidu.com/view/d8f13dc45fbfc77da269b126.html 2

Dancing Links 小结 (因为之前丢了一次稿,未完待续)

Dancing Links (DLX)是Knuth为了解决精确覆盖问题而提出的算法,很多搜索问题可以转化位精确覆盖问题从而使用Dancing Links解决(效率会比DFS高很多,因为里面常常蕴涵着意想不到的剪枝) 信息学竞赛中的DLX的问题类似网络流,只需建图+贴版即可 参考文献: 1.DLX的原理:Knuth的论文: 原版:http://arxiv.org/abs/cs/0011047 翻译版:http://wenku.baidu.com/view/d8f13dc45fbfc77da269b

使用双向十字链表(或Dancing Links)解数独游戏

#include<stdio.h> #include<string.h> #include<algorithm> using namespace std; struct Data { void assign(int x,int y,int z) { row=x; col=y; val=z; } int row,col,val; } data[730]; struct Node { Node(int x=0,int y=0): row(x),col(y),up(this)