Eight HDU 1043 AND POJ 1077

原创 2018年04月16日 17:55:00
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

整理了好长时间,终于解决了。  刚开始一直纠结康拓展开式,后来通过资料查找,进一步的了解。

    康拓展开式

//判断这个数在其各个数字全排列中从小到大排第几位
// X = an*(n-1)! + an-1*(n-2)! + ... + a2*1! + a1*0!; 

int cator(int t[])                            //康拓展开式
{
	int sum = 0;
	for(int i = 0; i < 9; i++)
	{
		int num = 0;
		for(int j = i+1; j < 9; j++)
			if(t[i] > t[j])
				num++;
		sum += num*fac[8-i];  //((n-1)-i)	  
	}
	return sum; 
}

    逆运算

int n;            //表示有几位数 
int book[110];
int fac[] = {1,1,2,6,24,120,720,5040,40320,362880};   //第 i!的数值 

// k = an*(n-1)! + an-1*(n-2) + ... + a2*1! + a1*0!;

void reverse_cator(int k,char s[])
{
    memset(book,0,sizeof(0)); 
    int j;
    for(int i = 0;i < n; i++)
    {
        int t = k/fac[n-i-1];      //表示的是 an; 
        for(j = 1; j <= n; j++)
            if(!vis[j])
            {
                if(t == 0)
                    break;
                --t;
            }
            
        s[i] = j+'0';
        vis[j] = 1;
        k = k%fac[n-1-i];        //继续往下找 
    }
}

刚开始做的是POJ 1077这道题,这道题是单租数据输入,可以从起始位置找终点位置,A了。

后来发现HDU 1043,本来想着可以秀一把了,可谁知竟然相同的代码,竟然来了个Compilation Error。

很绝望,后来得知1043这题是多组数据输入,然后就换种思路,开始从最终位置出发,找到所有的点,并保存其路径。在这里,应注意运用数组实现邻接表。

//逆向搜索,从终点往前搜索 
#include<stdio.h>
#include<queue>
#include<string.h>
#include<iostream> 
#include<algorithm>
using namespace std;

int a[]={-1,1,0,0};
int b[]={0,0,-1,1};

char str[]={"durl"};     //由于从终点往前找,故方向相反 

int fac[]={1,1,2,6,24,120,720,5040,40320,362880};

int book[370000]; 		

struct note			//存储路径 
{	
	int head;		//表示的是 
	char st;			//存储方向 
	
}f[370000];

struct node
{
	int x0;
	int num;			//s[]在全排列中从大到小第几位 
	int s[10];		    // 存储数康拓展开式	所求的数值 
};

//判断这个数在其各个数字全排列中从小到大排第几位
// X = an*(n-1)! + an-1*(n-2)! + ... + a2*1! + a1*0!; 

int cator(int t[])                            //康拓展开式
{
	int sum = 0;
	for(int i = 0; i < 9; i++)
	{
		int num = 0;
		for(int j = i+1; j < 9; j++)
			if(t[i] > t[j])
				num++;
		sum += num*fac[8-i];  //((n-1)-i)	  
	}
	return sum; 
}

void bfs()
{
	memset(book,0,sizeof(book));
	queue<node>Q;
	node now,tmp;
	for(int i = 0; i < 8; i++)
		now.s[i] = i+1;
	now.s[8] = 0;
	now.x0 = 8;
	now.num = 0;
	f[0].head = 0;
	Q.push(now);
	while(!Q.empty())
	{
		now = Q.front();
		Q.pop();
		int x = now.x0/3;
		int y = now.x0%3; 
		for(int i = 0;i < 4; i++)
		{
			int tx = x + a[i];
			int ty = y + b[i];
			if(tx < 0 || ty < 0 || tx > 2 || ty > 2 )
				continue;
			tmp = now;
			tmp.x0 = tx*3 + ty;
			swap(tmp.s[tmp.x0],tmp.s[now.x0]);
			tmp.num = cator(tmp.s);
			if(!book[tmp.num])
			{
				book[tmp.num] = 1;
				f[tmp.num].head = now.num;		//此时的数连接着上一个状态 now.head 
				f[tmp.num].st =  str[i];
				Q.push(tmp);
			}
		}
	}
	return ;
}

int main()
{
	char c;
	int t[10];  
	bfs();
	while(cin >> c)            //cin不吸收空格回车等字符
	{
		if(c == 'x')
			t[0] = 0;
		else
			t[0] = c-'0';
		for(int i = 1; i < 9; i++)
		{
			cin >> c;
			if(c == 'x')
				t[i] = 0;
			else
				t[i] = c-'0';
		}
		int n = cator(t);
		//printf("%d\n",n);
		if(book[n])
		{
			while(n)
			{
				printf("%c",f[n].st);
				n = f[n].head;			//下一个状态 
			}
			printf("\n");
		}
		else
			printf("unsolvable\n"); 
	}
	return 0;
}

在这里,要注意的是

   1  我们是从后往前找的,所有方向应该正好相反(上下左右的坐标,  保存的字符应该是下上右左)

   2  数据有多重答案,所有不要一直纠结自已的运行结果和测试数据不一样啊。

在这里,把字符'x'变成0或者9都可以

重在尝试哦,说不定自己就对了呢




版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/Qin7_Victory/article/details/79963413

HDU 1043 ,POJ 1077 Eight

一、数据如何存储和表示? 1、可以用整形来表示八数码的状态,x可以当作“9”,“0”不好处理,例如终态12345678x,可以表示成整数123456789, 2、用数组来存储,这里x可以用0或9来表示...
  • starcuan
  • starcuan
  • 2014-02-06 17:00:11
  • 1098

hdu 1043/poj 1077 Eight (八数码 经典搜索题 bfs + 康托展开)

听说不做此题人生不完整,吓得我赶紧做了。
  • W1413882708
  • W1413882708
  • 2016-10-06 20:34:27
  • 623

hdu1043 Eight(A*/双向BFS/单项BFS打表+康托展开)

题目链接:点击打开链接 题意描述:经典八数码问题,给定八数码的初始序列,求经过u、r、l、d四种操作到达1 2 3 4 5 6 7 8 x的状态,打印出操作序列? 解题思路:A*/双向BFS/单项...
  • mengxingyuanlove
  • mengxingyuanlove
  • 2015-10-11 17:42:22
  • 1177

【HDU 1043】Eight(A*启发式搜索算法)

DescriptionThe 15-puzzle has been around for over 100 years; even if you don’t know it by that name,...
  • iceiceicpc
  • iceiceicpc
  • 2016-08-04 15:52:59
  • 495

HDU_1043 Eight

http://acm.hdu.edu.cn/showproblem.php?pid=1043 转载请注明出处,谢谢 http://blog.csdn.net/ACM_cxlove?viewmode=...
  • S031302306
  • S031302306
  • 2015-11-06 19:28:07
  • 288

hdu 1043 Eight(八数码问题 高级搜索: A* 搜索)

Problem Description The 15-puzzle has been around for over 100 years; even if you don't know it b...
  • xiaosshhaa
  • xiaosshhaa
  • 2017-01-10 17:42:52
  • 342

hdu 1043 Eight 双向BFS/A*算法

终于被我水过了,哈哈,45
  • a601025382s
  • a601025382s
  • 2014-07-24 20:42:48
  • 3348

HDU1043 Eight(八数码:逆向BFS打表+康托展开)题解

EightTime Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submi...
  • qq_14938523
  • qq_14938523
  • 2018-03-05 11:52:41
  • 28

Eight HDU - 1043 八数码 A*算法

康托展开判重。也可以用打表和双向bfs做。 第一个A*搜索,A*是一种启发式搜索,g为已花代价,h为估计的剩余代价,而A*是根据f=g+h作为估价函数进行排列,也就是优先选择可能最优的节点进行扩展。...
  • WsMiracle
  • WsMiracle
  • 2017-09-06 11:02:55
  • 92

Eight POJ - 1077 (HDU - 1043)

点击打开链接普通bfs预处理 通过康拓展开进行状压 找出所有符合题意的排列#include &amp;lt;cstdio&amp;gt; #include &amp;lt;cstring&amp;gt...
  • sunyutian1998
  • sunyutian1998
  • 2018-03-08 14:49:11
  • 5
收藏助手
不良信息举报
您举报文章:Eight HDU 1043 AND POJ 1077
举报原因:
原因补充:

(最多只允许输入30个字)