八数码:
题目描述:
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);
}
}