poj 1077-Eight;hdu 1043-Eight

最新推荐文章于 2021-05-21 10:34:47 发布
最新推荐文章于 2021-05-21 10:34:47 发布
阅读量799 收藏
点赞数
分类专栏： 杭电HDU 搜索 北京大学POJ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq276291420/article/details/9375657
版权

点击打开链接hud

点击打开链接poj

Eight

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 9141    Accepted Submission(s): 2459
Special Judge

Problem Description
The 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 on it, and all packed into a 4 by 4 frame with one tile missing. Let's call the missing tile 'x'; the object of the puzzle is to arrange the tiles so that they are ordered as:  
 1  2  3  4
 5  6  7  8
 9 10 11 12
13 14 15  x

where the only legal operation is to exchange 'x' with one of the tiles with which it shares an edge. As an example, the following sequence of moves solves a slightly scrambled puzzle:  
 1  2  3  4     1  2  3  4     1  2  3  4     1  2  3  4
 5  6  7  8     5  6  7  8     5  6  7  8     5  6  7  8
 9  x 10 12     9 10  x 12     9 10 11 12     9 10 11 12
13 14 11 15    13 14 11 15    13 14  x 15    13 14 15  x
            r->            d->            r->

The letters in the previous row indicate which neighbor of the 'x' tile is swapped with the 'x' tile at each step; legal values are 'r','l','u' and 'd', for right, left, up, and down, respectively. 

Not all puzzles can be solved; in 1870, a man named Sam Loyd was famous for distributing an unsolvable version of the puzzle, and 
frustrating many people. In fact, all you have to do to make a regular puzzle into an unsolvable one is to swap two tiles (not counting the missing 'x' tile, of course). 

In this problem, you will write a program for solving the less well-known 8-puzzle, composed of tiles on a three by three 
arrangement.
 

Input
You will receive, several descriptions of configuration of the 8 puzzle. One description is just a list of the tiles in their initial positions, with the rows listed from top to bottom, and the tiles listed from left to right within a row, where the tiles are represented by numbers 1 to 8, plus 'x'. For example, this puzzle 

1 2 3 
x 4 6 
7 5 8 

is described by this list: 

1 2 3 x 4 6 7 5 8
 

Output
You will print to standard output either the word ``unsolvable'', if the puzzle has no solution, or a string consisting entirely of the letters 'r', 'l', 'u' and 'd' that describes a series of moves that produce a solution. The string should include no spaces and start at the beginning of the line. Do not print a blank line between cases.
 

Sample Input 
  
  

   
   2  3  4  1  5  x  7  6  8
 

Sample Output 
  
  

   
   ullddrurdllurdruldr


这题折腾了我一晚上,八数码问题是一开始就学过的问题,可是没想到这个题在杭电上要求居然这么高,POJ只有一组数据,1AC单向广搜就能过,不过这次是要双向广搜,所以写的很多也很乱,中间还参考了一点北大的课件,,杭电的数据很严,只有双向广搜也过不了,必须加剪枝,就是一开始就判断可不可行,最后才2800MS过的,康托展开忘了,又去百度查的,双向广搜写起来特别麻烦,还很容易错,对于我这种菜鸟,如果要参加比赛估计要带个模板去了,哎

AC代码 POJ 63MS HDU 2796MS

#include<stdio.h>
#include<queue>
#include<string.h>
#include<iostream>
using namespace std;
int father[370000][2];
short hash[370000];
int zeropoint[370000];

int factory[12] = { 0, 1, 2, 6, 24, 120,720, 5040, 40320, 362880 };
int array[10] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
int contor(int num)
{
	char str[10];
	sprintf(str, "%.9d", num);
	int len = 9;
	int i, j, res = 0;
	for(i = 0; i < len; i++)
	{
		int count = 0;
		for(j = i + 1; str[j]; j++)
		{
			if(str[i] > str[j])
				count ++;
		}
		res += count * factory[len - i - 1];
	}
	return res + 1; 
}
int getZero(int num)
{
	int i = 8;
	while(num > 0)
	{
		int n = num / array[i];
		if(n == 0)
			return 9 - i - 1;
		num %= array[i];
		i--;
	}
	return 8;
}
void printfather(int child, int f)
{
	if(father[child][0] == 0)
		return;
	if(father[child][0] == f)
	{
		switch(father[child][1])
		{
		case 1:
			printf("u");
			break;
		case 2:
			printf("d");
			break;
		case 3:
			printf("l");
			break;
		case 4:
			printf("r");
			break;
		}
		return;
	}
	printfather(contor(father[child][0]), f);
	switch(father[child][1])
	{
	case 1:
		printf("u");
		break;
	case 2:
		printf("d");
		break;
	case 3:
		printf("l");
		break;
	case 4:
		printf("r");
		break;
	}
}
void prints(int child)
{
	switch(father[child][1])
	{
	case 1:
		printf("d");
		break;
	case 2:
		printf("u");
		break;
	case 3:
		printf("r");
		break;
	case 4:
		printf("l");
		break;
	}
}
void bfs(int num)
{
	queue<int> head, tail;
	hash[contor(123456780)] = 2;
	hash[contor(num)] = 1;
	zeropoint[contor(123456780)] = getZero(123456780);
	zeropoint[contor(num)] = getZero(num);
	head.push(num);
	tail.push(123456780);
	char str[10];
	while(!head.empty() && !tail.empty ())
	{
		if(head.size() < tail.size())
		{
			int curr = head.front();
			head.pop();
			sprintf(str, "%.9d", curr);
			char str2[10];
			int zero = zeropoint[contor(curr)];
			int numb;
			if(zero > 2)
			{
				strcpy(str2, str);
				char swap = str2[zero - 3];
				str2[zero - 3] = str2[zero];
				str2[zero] = swap;
				sscanf(str2,"%d",  &numb);
				int flag = contor(numb);
				if(hash[flag] == 2)
				{
					printfather(contor(curr), num);
					printf("u");
					int j;
					int c = contor(1234567890);
					for(j = flag; j != c ; j = contor(father[j][0]))
					{
						prints(j);
					}
					return;
				}
				else if(hash[flag] == 0)
				{
					father[flag][0] = curr;
					father[flag][1] = 1;
					hash[flag] = 1;				
					zeropoint[flag] = zero - 3;
					head.push(numb);
				}
			}
			
			if(zero < 6)
			{
				strcpy(str2, str);
				char swap = str2[zero + 3];
				str2[zero + 3] = str2[zero];
				str2[zero] = swap;
				sscanf(str2,"%d",  &numb);
				int flag = contor(numb);
				if(hash[flag] == 2)
				{
					printfather(contor(curr), num);
					printf("d");
					int j;
					int c = contor(1234567890);
					for(j = flag; j != c ; j = contor(father[j][0]))
					{
						prints(j);
					}
					return;
					
				}
				else if(hash[flag] == 0)
				{
					father[flag][0] = curr;
					father[flag][1] = 2;
					hash[flag] = 1;				
					zeropoint[flag] = zero + 3;
					head.push(numb);
				}
			}
			if(zero % 3 < 2)
			{
				strcpy(str2, str);
				char swap = str2[zero + 1];
				str2[zero + 1] = str2[zero];
				str2[zero] = swap;
				sscanf(str2,"%d",  &numb);
				int flag = contor(numb);
				
				if(hash[flag] == 2)
				{
					printfather(contor(curr), num);
					printf("r");
					int j;
					int c = contor(1234567890);
					for(j = flag; j != c ; j = contor(father[j][0]))
					{
						prints(j);
					}
					return;
				}
				else if(hash[flag] == 0)
				{
					father[flag][0] = curr;
					father[flag][1] = 4;
					hash[flag] = 1;				
					zeropoint[flag] = zero + 1;
					head.push(numb);
				}
			}
			if(zero % 3 > 0)
			{
				strcpy(str2, str);
				char swap = str2[zero - 1];
				str2[zero - 1] = str2[zero];
				str2[zero] = swap;
				sscanf(str2,"%d",  &numb);
				int flag = contor(numb);
				if(hash[flag] == 2)
				{
					printfather(contor(curr), num);
					printf("l");
					int j;
					int c = contor(1234567890);
					for(j = flag; j != c ; j = contor(father[j][0]))
					{
						prints(j);
					}
					return;
				}
				else if(hash[flag] == 0)
				{
					father[flag][0] = curr;
					father[flag][1] = 3;
				
					hash[flag] = 1;				
					zeropoint[flag] = zero - 1;
					head.push(numb);
				}
			}
		}
		else
		{
			int curr = tail.front();
       		tail.pop();
//			printf("2: %.9d\n", curr);
			sprintf(str, "%.9d", curr);
			char str2[10];
			strcpy(str2, str);
			int zero = zeropoint[contor(curr)];
			int numb;
			if(zero > 2)
			{
				strcpy(str2, str);
				char swap = str2[zero - 3];
				str2[zero - 3] = str2[zero];
				str2[zero] = swap;
				sscanf(str2,"%d",  &numb);
				int flag = contor(numb);
				if(hash[flag] == 1)
				{
					printfather(flag, num);
					printf("d");
					int j;
					int c = contor(1234567890);
					for(j = contor(curr); j != c ; j = contor(father[j][0]))
					{
						prints(j);
					}
					return;
				}
				else if(hash[flag] == 0)
				{
					father[flag][0] = curr;
			
					father[flag][1] = 1;
					hash[flag] = 2;				
					zeropoint[flag] = zero - 3;
					tail.push(numb);
				}
			}
			
			if(zero < 6)
			{
				strcpy(str2, str);
				char swap = str2[zero + 3];
				str2[zero + 3] = str2[zero];
				str2[zero] = swap;
				sscanf(str2,"%d",  &numb);
				int flag = contor(numb);
				if(hash[flag] == 1)
				{
					printfather(flag, num);
					printf("u");
					int j;
					int c = contor(1234567890);
					for(j = contor(curr); j != c ; j = contor(father[j][0]))
					{
						prints(j);
					}
					return;
					
				}
				else if(hash[flag] == 0)
				{
					father[flag][0] = curr;			
					father[flag][1] = 2;
					hash[flag] = 2;				
					zeropoint[flag] = zero + 3;
					tail.push(numb);
				}
			}
			if(zero % 3 < 2)
			{
				strcpy(str2, str);
				char swap = str2[zero + 1];
				str2[zero + 1] = str2[zero];
				str2[zero] = swap;
				sscanf(str2,"%d",  &numb);
				int flag = contor(numb);
				
				if(hash[flag] == 1)
				{
					printfather(flag, num);
					printf("l");
					int j;
					int c = contor(1234567890);
					for(j = contor(curr); j != c ; j = contor(father[j][0]))
					{
						prints(j);
					}
					return;
				}
				else if(hash[flag] == 0)
				{
					father[flag][0] = curr;
					father[flag][1] = 4;
					hash[flag] = 2;				
					zeropoint[flag] = zero + 1;
					tail.push(numb);
				}
			}
			if(zero % 3 > 0)
			{
				strcpy(str2, str);
				char swap = str2[zero - 1];
				str2[zero - 1] = str2[zero];
				str2[zero] = swap;
				sscanf(str2,"%d",  &numb);
				int flag = contor(numb);
				if(hash[flag] == 1)
				{
					printfather(flag, num);
					printf("r");
					int j;
					int c = contor(1234567890);
					for(j = contor(curr); j != c ; j = contor(father[j][0]))
					{
						prints(j);
					}
					return;
				}
				else if(hash[flag] == 0)
				{
					father[flag][0] = curr;
					father[flag][1] = 3;
				
					hash[flag] = 2;				
					zeropoint[flag] = zero - 1;
					tail.push(numb);
				}
			}
		}
	}
	printf("unsolvable");
}
int main()
{
	
//	freopen("in.txt", "r", stdin);
	char str[20];
//	gets(str);
	while(cin.getline(str, 48))
	{
		memset(father, 0, sizeof(father));
		memset(hash, 0, sizeof(hash));
		memset(zeropoint, 0, sizeof(zeropoint));
		int i;
		char ch;
		int number = 0;
		int j = 0;
		for(i = 0; i < 9; i++, j ++)
		{

			while(sscanf(str + j, "%c", &ch), ch != 'x' && (ch < '0' || ch > '9'))
				j++;
			if(ch == 'x')
				ch = '0';
			number = number * 10 + ch - '0'; 
		}
		sprintf(str, "%.9d", number);

		int sumGoal = 0;
		for(i = 0;i < 8; ++i )
			sumGoal += i -1;
		int sumOri = 0;
		for(i = 0;i < 9 ; ++i ) {
			if( str[i] == '0')
				continue;
			for( int j = 0; j < i; ++j ) {
				if( str[j] < str[i] && str[j] != '0' )
					sumOri ++;
			}
		}
		if( sumOri %2 != sumGoal %2 ) {
			printf("unsolvable\n");
			continue;
		}

	//	printf("%d", number);
		if(number != 123456780)
			bfs(number);
		printf("\n");		
	}
//	printf("%d %d\n", contor(23185476), contor(120743658));
	return 0;
}


勇敢的炮灰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
八数码（POJ-1077或HDU-1043）
白黑菜的博客
04-21 395
Eight The 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 on it, and a
A*(A - Star) - Eight - HDU - 1043
njuptACMcxk的博客
05-22 232
A*(A - Star) - Eight - HDU - 1043 题意： 给定一个3×3的方阵，包含数字1给定一个3×3的方阵，包含数字1给定一个3×3的方阵，包含数字1~8，以及字符′x′(表示空位)，每次操作通过上下左右移动数字到′x′所在的空位上，使得最终呈现一个有序的9宫格。8，以及字符'x'(表示空位)，\\每次操作通过上下左右移动数字到'x'所在的空位上，使得最终呈现一个有序的9宫格。8，以及字符′x′(表示空位)，每次操作通过上下左右移动数字到′x′所在的空位上，使得最终呈现一个有序的9宫格
Eight POJ - 1077 (HDU - 1043)
sunyutian1998的博客
03-08 215
  点击打开链接     普通bfs预处理 通过康拓展开进行状压 找出所有符合题意的排列   #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;algorithm&gt; using namespace std; struct node { int val; int id; char ...
POJ-1077 HDU 1043 HDU 3567 Eight (BFS预处理+康拓展开）
weixin_30326745的博客
09-06 108
思路： 这三个题是一个比一个令人纠结呀。 POJ-1077 爆搜可以过，94ms，注意不能用map就是了。 #include<iostream> #include<stack> #include<queue> #include<map> #include<cstring> using namespace std; ...
HDU - 1043 - Eight / POJ - 1077 - Eight
weixin_30662109的博客
07-12 81
先上题目： Eight Time Limit: 10000/5000 MS (Java/Others)Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 11243Accepted Submission(s): 3022Special Judge Problem Description The 15-p...
POJ 1077 Eight & HDU 1043 Eight（康托展开+BFS）
Noooooorth的专栏
07-13 381
题目链接：1077 -- Eight Problem - 1043 两个题目几乎完全一致。不同的是，HDU的八数码这道题需要一次bfs，起点为123456789X，遍历完所有状态，同时用pre数组记录上一个状态，然后每次输入只需要一个while进行O（1）的查询。 方法没有什么特殊的，我用的是普通的bfs。这道题和其他的搜索题目不一样的一点是，9个格子，太大没有办法标记。这时可以利用康托展开。
HDU-1043 POJ -1077 Eight（A*算法）
zitian246的博客
04-12 591
The 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 on it, and all packed...
POJ-1077 HDU-1043 Eight(单广,双广,启发式搜索)
L.
07-30 392
原题链接 Eight Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 29854   Accepted: 12989   Special Judge Description The 15-puzzle has been around for ove
HDU---1043 POJ 1077 Eight 八数码问题 广度优先搜索 康拓展开
sgh666666的博客
07-28 182
问题：很经典的搜索，给定一个3*3的方格，里面放1-8个数字，有一个空格，空位可以与相邻的数字可以移到空格中，问给定一个状态，怎么移动到一个特定的状态（比如1-8顺序存放）。 康拓展开记录当前的状态，BFS即可。 HDU 1043是让给定多组状态，怎么还原成1-8顺序存放，可以倒叙BFS，打标出所有状态， POJ 1077是一组数据，直接正向搜索即可。 思考：A*怎么解决这道题...
搜索专题突破POJ1077 POJ1324 POJ2046 HDU2485 HDU1560 HDU1667 POJ3134 POJ1915 HDU1401 HDU1430 HDU2691
Luowaterbi的博客
08-18 373
POJ1077Eight 八数码问题，就是手机上那个智能拼图的小游戏感觉很小的时候在诺基亚上玩过。只有一个块可以上下左右移动，问能否拼好。 IDA*搜索。估值函数就是目前拼图的曼哈顿距离。这是最理想化的情况，就是只经过曼哈顿距离，所有拼图回到自己位置。因为每次只能改变一个拼图的位置。所以最少就是曼哈顿距离。 估值函数的选取，就是去想最最理想的情况需要多少步达到目标。一般最理想都是实现不了，需...
HDU 1043 Eight poj 1077 （八数码 启发式搜索）
qwesde
08-30 479
题目链接 poj1077 hdu1043使用A*搜索就可以了 A*是bfs的一种优化，使用函数F做为每个节点的访问的优先级hdu的需要先判断是否有解，否则会tle，加上后跑了1000+ms poj的不用判断，也可以ac，跑了40+ms一个状态表示成一维的形式，求出除0之外所有数字的逆序数之和，也就是每个数字前面比它大的数字的个数的和，称为这个状态的逆序。 若两个状态的逆序奇偶性 相同，则可
kuangbin带你飞 专题1-23 题单
HelloACM_ICPC的博客
01-27 2699
kuangbin大神，对于打过ACM比赛的ACMer，无人不知无人不晓。 在此，附上vjudge平台上一位大神整理的[kuangbin带你飞]专题目录链接。 [kuangbin带你飞专题目录1-23] : https://vjudge.net/article/187 专题一 简单搜索 POJ 1321 棋盘问题 POJ 2251 Dungeon Master POJ 3278 Catch That...
老鱼的-kuangbin专题题解
DeathYmz的博客
04-07 1426
kuangbin专题问题一览 专题一 简单搜索 POJ 1321 棋盘问题 POJ 2251 Dungeon Master POJ 3278 Catch That Cow POJ 3279 Fliptile POJ 1426 Find The Multiple POJ 3126 Prime Path POJ 3087 Shuffle’m Up POJ 3414 Pots FZU...
c语言15-puzzle解法,15 Puzzle (4乘4谜题) IDA*(DFS策略与曼哈顿距离启发) 的C语言实现...
weixin_28221255的博客
05-21 762
大家好！这是我的第一篇博客，由于之前没有撰写博客的经验，并且也是初入计算机和人工智能领域，可能有些表述或者理解不当，还请大家多多指教。一、撰写目的由于这个学期在上算法与数据结构课程的时候，其中一个大作业是用C语言和深度优先(DFS)的IDA*(基于迭代加深的A*算法)实现快速寻求15Puzzle(4乘4迷题)的解法的工具，同时尽可能地加入优化使得算法尽可能快速、简练。我发现网上很少有关于利用ID...
POJ 1062 (nyoj - 510）昂贵的聘礼
云淡风清
07-25 2479
点击打开链接 昂贵的聘礼 时间限制：1000 ms  |  内存限制：10000 KB 难度：4 描述      年轻的探险家来到了一个印第安部落里。在那里他和酋长的女儿相爱了，于是便向酋长去求亲。酋长要他用10000个金币作为聘礼才答应把女儿嫁给他。探险家拿不出这么多金币，便请求酋长降低要求。酋长说："嗯，如果你能够替我弄到大祭司的皮袄，我可以只要8
poj 1018 Communication System
云淡风清
08-18 1720
点击打开链接 Communication System Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 21007   Accepted: 7449 Description We have received an order from Pizoor
poj 1804 （nyoj 117）Brainman ： 归并排序求逆序数
云淡风清
08-29 1505
点击打开链接 Brainman Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 7810   Accepted: 4261 Description Background  Raymond Babbitt drives his brother Charli
poj 1806 Manhattan 2025
云淡风清
11-21 1277
点击打开链接 #include #include char map[10][30][30]; void printmap(int num, int n) { int i, j; int temp = n * 2 + 1; for(i = 1; i <= temp; i++) { for(j = 1; j <= temp; j++)
解密15拼图：从POJ 1077 Eight探讨解题策略
"这是一个关于ACM竞赛中的Poj 1077 Eight问题的讨论，主要涉及15拼图游戏的解决策略和算法。" 在计算机科学领域，特别是算法设计和编程竞赛（如ACM）中，解决问题的能力是至关重要的。Poj 1077 Eight是一个基于15...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

勇敢的炮灰

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值