POJ~1077~八数码~A*解题报告

八数码：

题目描述：

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 a description of a configuration of the 8 puzzle. The 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.。

Sample Input：

 2  3  4  1  5  x  7  6  8 

Sample Output：

ullddrurdllurdruldr

题目大意：

其实这道题很简单理解，就是简单的九宫格排序问题，而只能移动上下左右这四个方向，并且还要满足1 2 3 4 5 6 7 8 x这样的排序即可，所以这道题可以用A*+康托定理去解。

思路分析：

这道题方向很简单，但是要实施起来有点困难，这里有很多种解法，类似BFS和双BFS，这里讲一下A*去解这道题，这道题它只需要将九宫格的数字，按顺序排序好就行，那么我们可以这样认为每一个数字到达属于它宫格所需要的代价为h，那么九个全部移动下来是H，这里我们可以将其看做是启发式函数（就是到达目的预估需要代价，这里是预估），因为这里是一个九宫格只有横竖，那么可以用曼哈顿函数来去代替它，那么实际移动只能一次只能移动一次，可以认为G（直接运动代价），那么可以得到公式实际运动代价为F=G+H，只要F为最小，说明所耗费的时间与代价也最小（所要运行的时间少，效率快）。以及当它的排序达到目的即为答案。这里解释相关原理：

曼哈顿距离：这里因为是九宫格，所以可以用2点坐标的绝对值差来表示所需要的代价，|x1-x2|+|y1-y2|这里即为上述所讲的h，将所有h相加即为H。
康托定理：
X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[1]*0!，
其中a[i]为当前未出现的元素中是排在第几个（从0开始）。这就是康
托展开
1. 举个简单的例子吧，例如（1，2，3，4）这四种数字全排列，如果要
求2134的排在全排列第几个，可以这样算：
2. 首位是2，比他小的有1，那么就有1*（4-1）！。
3. 第二位是1，没有比他小，那么就有0*（4-2）！。
4. 第三位是3，比他小的有 1和2，但是1和2都已经出现在前面了，所以
   0*（4-3）!
5. 第四位是4，比他小的有1和2和3，但是都出现在前面，所以有0*(0)!
6. 最后将其全部相加就是该数字在全排列中的排序。

代码：

#include<iostream>
#include<cstdio>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<algorithm>
#include<vector>
#include<cmath>
#include<string.h>
#define me(a,b) memset((a),(b),sizeof((a)))//定义memset形式 
using namespace std;
const int maxn=363000;//因为只计算!9的阶级 
const int ATM=1;// 123456789的Hash的值 
int di1[5][2]={{1,0},{-1,0},{0,1},{0,-1}};//方向变量 
char di2[5]={"durl"};//方向变量 
char pr[maxn];//存储方向变量 
int pre[maxn];//存储父子点 
int visit[maxn];//标记是否访问过 
int fc[]={1,1,2,6,24,120,720,5040,40320,362880}; //0~9的阶乘 
typedef struct Node
{
	int c1[10];//记录九宫格元素 
	int num;//记录Hash值 
	int ans;//记录位置 
	int g,h,f; 
	bool operator<(const Node x)const//改变优先队列的弹出方式 
	{
		return f>x.f;//f表示当前值 
	 }//该方式是优先弹出小的 
}Lemon;
priority_queue<Lemon> q;//创建优先队列 
int dis(int s[])//找到曼哈顿值 
{
	int sum=0;
	for(int i=0;i<9;i++)
	{
		if(s[i]!=9)//这里不能为9，如果为9，无法继续扩展下去。 
		{
			int x = i/3, y = i%3;
        int x1 = (s[i]-1)/3, y1 = (s[i]-1)%3;
        sum += abs(x-x1) + abs(y-y1);
		}
	}
	return sum;
}
int Hash(int s1[])//康托定理正向解密 
{
	int sum=1;
	for(int i=0;i<9;i++)
	{
		int temp=0;
		for(int j=i+1;j<9;j++)
		{
			if(s1[j]<s1[i])
			{
				temp++;
			}
		}
		sum+=temp*fc[9-i-1];
	}
	return sum;
}
int LemonBFS(Lemon Frist)//BFS搜索 
{
	Lemon now;
	me(visit,0);
	visit[Frist.num]=1;//标记该点Hash值已经找过 
	pre[Frist.num]=-1;//设置根为-1 
	Frist.g=0;
	Frist.h=dis(Frist.c1);
	Frist.f=Frist.g+Frist.h;
	q.push(Frist);
	while(!q.empty())
	{
		now=q.top();
		q.pop();
		if(now.num==ATM)//如果Hash值等于1，说明已经找到123456789了可以退出 
		{
			return 1;
		}
		int x=now.ans/3;
		int y=now.ans%3;
		//找位置 
		for(int i=0;i<4;i++)
		{
			Lemon tp=now;
			int x1=x+di1[i][0];
			int y1=y+di1[i][1];
			if(x1<0 || y1<0 || x1>2 || y1>2)//判断边界 
			continue;
			else
			{
				tp.ans=x1*3+y1;
				tp.c1[now.ans]=tp.c1[tp.ans];
				tp.c1[tp.ans]=9;
				//交换元素 
				tp.num=Hash(tp.c1);
				if(!visit[tp.num])
				{
					visit[tp.num]=1;
					tp.g++;//g值 
					tp.h=dis(tp.c1);//找h值 
					tp.f=tp.h+tp.g;//f值 
					pre[tp.num]=now.num;//记录父子点 
					pr[tp.num]=di2[i];//记录方向操作 
					q.push(tp);//入队 
				}
			}
		}
	}
	return 0;
}
void print(int ATM)
{
	if(pre[ATM]==-1)//当等于-1说明到达了根了，可以回溯了 
	{
		return;
	}
	else
	{
	  print(pre[ATM]);//递归 
	  cout << pr[ATM];	
	}
}
int main()
{
	Lemon Frist;
	char ch;
	for(int i=0;i<9;i++)
	{
		cin >> ch;
		if(ch=='x')
		{
			Frist.c1[i]=9;
			Frist.ans=i;
		}
		else
		{
			Frist.c1[i]=ch-'0';
		}
	}
	Frist.num=Hash(Frist.c1);
	if(!LemonBFS(Frist))//输出 
	{
		cout << "unsolvable";
	}
	else
	{
		print(ATM);
	}
}